Multicast Packing for Coding across Multiple Unicasts

Transcription

1 Multicast Packing for Coding across Multiple Unicasts Chun Meng INC, CUHK & EECS, UC Irvine Athina Markopoulou EECS, UC Irvine Hulya Seferoglu LIDS, MIT Kenneth W. Shum, Chung Chan INC, CUHK Abstract We consider the problem of inter-session network coding for multiple unicast flows over directed acyclic graphs. Our approach consists of the following steps: (i) The unicast flows are partitioned into multiple disjoint subsets of unicast flows; (ii) each subset of unicast flows is mapped to a multicast flow, and linear network codes are constructed for these multicast flows. These linear network codes collectively serve as a linear network code for the original multiple unicast flows, which we refer to as multicast-packing code (MPC). We formulate a linear program to evaluate the performance of MPC for a given partition of the unicast flows. We also propose a practical algorithm, using simulated annealing, for finding such a partition. Using simulations, we demonstrate the benefits of the multicast packing code in terms of achievable common rate and cost, as well as the efficiency of the partitioning algorithm. I. INTRODUCTION Network coding was originally introduced to maximize the rate of a multicast flow over a network [] [2]. Network code design for this scenario has been solved using polynomialtime deterministic algorithms [3] or a random approach [4]. Yet, network coding across different sessions, which includes multiple unicasts as a special case, remains a well-known open problem. It has been shown that even determining whether there exists a linear network coding solution to such a problem is NP-hard [6]. Thus, constructive and sub-optimal approaches, such as [7] [2], have been proposed and shown to improve over routing for multiple unicasts. In this paper, we introduce a constructive inter-session network coding scheme for multiple unicast flows, illustrated in the following example. Example. Let us consider the network N shown in Fig. a. In this network, five unicast flows coexist in the network, where each edge has unit capacity. The ith unicast flow ( i 5) is denoted by ω i = (s i, d i ), where s i and d i are the sender and the receiver of ω i, respectively. The set of unicast flows are represented by Ω = {ω i : i 5}. Let us partition Ω into two disjoint sets, Ω = {ω, ω 2, ω 3 } and Ω 2 = {ω 4, ω 5 }. Also, N is partitioned into two sub-graphs N and N 2. The flows in Ω and Ω 2 are only transmitted over their respective subgraphs; i.e., flows in Ω (Ω 2 ) are transmitted only over N (N 2 ). Then we construct our codes to be the network codes for two multicast scenarios: In N, d, d 2 and d 3 require all the source symbols transmitted by s, s 2 and s 3 ; in N 2, d 4 and d 5 require all the source symbols transmitted by s 4 and s 5. These network codes also serve as network codes for the original multiple unicast flows. Note that several partitions of Ω, other than Ω and Ω 2 discussed in this example, are also possible. Part of the (a) Fig.. A motivating example. In the network N shown in (a), five unicast flows coexist. In (b), these unicast flows are partitioned into two subsets, Ω = {ω, ω 2, ω 3 } and Ω 2 = {ω 4, ω 5 }, and the network N is partitioned into two sub-graphs N and N 2. Note that the unicast flows in Ω are transmitted only over N, while the unicast flows in Ω 2 are transmitted only over N 2. Then, we construct linear network codes for Ω and Ω 2 separately, as shown in (b), where X i ( i 5) denotes the source symbol transmitted by s i. Note that the constructed network codes are network codes for two multicast scenarios over N and N 2. contribution of this paper is how to find good partitions. The example demonstrates the approach we follow in this paper. First, we partition the set of unicast flows into disjoint subsets of unicast flows. Second, we map each subset of unicast flows to a multicast flow with the same set of receivers, and linear network codes are constructed for these multicast problems by a deterministic [3] or a random approach [4]. These linear network codes collectively serve as a network code for the original unicast flows, which we refer to as Multicast-Packing Code (MPC). MPC has the following strengths. First, the MPC approach, i.e., partitioning the unicast flows to subsets of unicast flows and mapping each subset to a multicast network coding problem, is general enough to be applied to any directed acyclic graph. Second, given a partition of the set of the unicast flows, we use a linear program to quickly analyze the performance, e.g., maximum common rate and minimum cost, achieved by MPC. In contrast, previous constructive approaches are difficult to analyze due to the lack of succinct mathematical formulations. For example, the integer linear programming (ILP) approach [7] is difficult to analyze since it needs to consider all possible butterfly structures in the network. The evolutionary approach [8] doesn t even have a mathematical formulation. Third, in order to find the best MPC, we only need to search the space of all partitions of the set of unicast flows, independently of the network size. This is clearly more efficient and scalable than other constructive approaches, whose combinatorial optimization involved the network graph in addition to the set of flows. For example, (b)

2 the approach in [7] uses integer linear programming to select the best set of butterflies considering all pairs of flows but also all possible coding points on the network topology. The evolutionary approach [8] involves a random walk in the space of local coding vectors, which does not scales well with the network size. Although independent of the network size, our search problem is still exponential in the number of unicast flows. This is why we utilize a suboptimal, yet efficient, simulating annealing technique to find good partitions of the unicast flows. Simulation results over appropriately chosen scenarios demonstrate the above points. The structure of the rest of the paper is as follows. Section II presents related work. Section III describes the problem setup. Section IV presents the multicast packing code approach. Section V presents a practical flow partitioning algorithm using simulated annealing. Section VI presents simulation results. Section VII concludes the paper. II. RELATED WORK The inter-session network coding problem across different flows, which includes multiple unicasts as a special case, is a well-known open problem. It has been shown that linear network codes may not be sufficient to achieve capacity region [5], and determining whether there exists a linear network coding solution is NP-hard [6]. Thus, constructive and suboptimal approaches have been considered. An integer linear programming (ILP) based approach is proposed in [7] for inter-session network coding across multiple unicasts. An evolutionary approach is proposed in [8] for the same problem. Both approaches have to face the scalability problem. For example, the ILP approach proposed in [7] needs to consider all possible butterflies in the network, the number of which increases exponentially with the network size; the evolutionary approach involves a random walk in the space of the local coding vectors in the network, which also scales up exponentially with the network size. Our main difference is that the search space in our problem is smaller: it depends only on the number of flows and not on the network size. However, the complexity is still exponential in the number of flows, and this is why we employ a suboptimal, yet efficient, simulated annealing partitioning algorithm. Pairwise inter-session network coding is proposed in [9] and [0]. A game theoretic approach to inter-session network coding for two unicast sessions is considered in []. A practical one-hop inter-session network coding scheme is proposed in [2] over wireless networks. Our main difference is that our approach is general exploit network coding opportunities across more than two unicast flows and multi-hop network coding. An improved genetic algorithm for finding coding matrix for multi-user scenario is proposed in [3]. An interference alignment approach is considered in [4] [5] [6]. However, this approach suffers the feasibility problem. Multicast packing were considered earlier, in [7], but this work doesn t consider network coding and its potential in improving rates. III. PROBLEM SET-UP We consider a weighted directed acyclic graph N = (V, E, h), where V and E denote the node set and the edge set respectively. h : E R 0 is a function such that for e E, h(e) equals the capacity of e. We allow multiple edges between two nodes, and hence E V V Z +, where the last integer enumerates edges between two nodes. The edges are denoted by (u, v, i). If no confusion arises, we simply use (u, v) to represent edges. The sets of incoming and outgoing edges at a node v are denoted by In(v) and Out(v), respectively. We denote the tail and the head of an edge e by head(e) and tail(e), respectively. A unicast flow is represented by a tuple ω = (s, d) V V, where s, d are the sender and receiver of ω, respectively. We consider a multiple-unicast scenario, represented by a set Ω of unicast flows that coexist in the network, i.e., Ω = {ω i = (s i, d i ) : i Ω }. The edge capacities can be any positive real number. In order to deal with possible non-integer capacities, we consider a time-extended version of the network as follows. We extend the length of a time slot by t times, where t is a positive integer. Hence, each edge e E can transmit at most k(e) = t h(e) symbols in an extended time slot. We use a network N (t) = (V, E (t), h (t) ) to represent this time-extended network: The node set of N (t) is the same as N ; for each e E, we add k(e) parallel edges from tail(e) to head(e) in E (t) ; each edge e E (t) has unit capacity, i.e., h (t) (e) =. We refer to N (t) as the t-extension network of N. We define the following notations to facilitate our discussion. Given Ω Ω, S(Ω ) and D(Ω ) denote the set of senders and the set of receivers involved in Ω, respectively. For (s i, d i ) Ω, X(s i ) denotes the vector of source symbols that s i transmits to d i. For v V, Z (v) denotes the vector of the symbols transmitted along the incoming edges at v, and the source symbols injected by v if v S(Ω); Z + (v) denotes the vector of the symbols transmitted along the outgoing edges at v. Given a vector A, A denotes the dimension of A. We make the following assumptions to simplify our analysis. (i) The source symbols transmitted by all the senders in S(Ω) are mutually independent random variables; (ii) the symbols transmitted in the network take values from a finite field F 2 m; (iii) each edge in E (t) represents an error-free and delay-free channel; (iv) the senders involved in Ω are all different, and so are the receivers involved in Ω. We consider scalar linear network coding over N (t). In this setup, at each node v V, Z (v) is mapped to Z + (v) via a linear equation, Z + (v) = Z (v)e(v), where E(v) is a Z (v) Z + (v) matrix on F 2 m. For each (s i, d i ) Ω, X(s i ) can be decoded at d i via a linear equation, X(s i ) = Z (d i )D(d i ), where D(d i ) is a Z (d i ) X(s i ) matrix on F 2 m. E(v) and D(d i ) are referred to as the encoding matrix at v and the decoding matrix at d i respectively. We group all the encoding matrices and decoding matrices into a set Φ (t), and refer to it as a scalar linear network code for the multipleunicast scenario Ω over N (t). The transmission rate of a unicast session (s i, d i ) achieved by Φ (t) is defined as r(s i ) = X(si). The rate vector achieved by Φ (t) is defined as r(φ (t) ) = (r(s i ) : s i S(Ω)). Given a vector r 0 R Ω 0, if there exists a sequence of scalar linear network codes, {Φ (tn) : n < }, where {t n } is a sequence of positive integers, and Φ (tn) is a scalar linear network code over the t n -extension network N (tn), such that lim n r(φ (tn) ) = r 0, we say that r 0 is linearly achievable. t

3 IV. PACKING MULTICASTS FOR MULTIPLE UNICASTS A. Multicast-Packing Code In this section, we present the idea of MPC, i.e., mapping multiple unicast flows to multicast flows when the partitions of the original multiple unicast flows are given. The partitioning problem is considered in Section V. We introduce the following notations to facilitate our discussion. We use γ = (s, D), where s V and D V, to represent a multicast flow such that the nodes in D all require the source symbols transmitted by s. A multicast scenario is represented by a set of multicast flows, i.e., Γ = {(s i, D) : i Γ }, where the nodes in D require all the source symbols transmitted by all s i s. A partition of the multiple-unicast scenario Ω is a set of non-empty disjoint subsets of Ω, G = {Ω i : i G }, such that Ω = G i= Ω i. Given a partition G, an allocation of network capacities is represented by a set of functions H = {h i : E R 0 : i G }, which satisfies the following condition: G h i(e) h(e) e E. () i= Given G and H, we can view each Ω i as a multiple-unicast scenario of smaller scale that works separately in a network N i = (V, E, h i ). For example, in Fig., the allocation of network capacities are as follows. If e is an outgoing edge of s, s 2, s 3, an incoming edge of d, d 2, d 3, or e = e, h (e) = ; otherwise, h (e) = 0. If e is an outgoing edge of s 4, s 5, an incoming edge of d 4, d 5, or e = e 2, h 2 (e) = ; otherwise, h 2 (e) = 0. Suppose G and H are already given. We construct a scalar linear network code for Ω over N (t) as follows. For each Ω i G, we construct a multicast scenario, Γ i = {(s j, D(Ω i )) : s j S(Ω i )}, over the t-extension network N (t) i = (V, E (t) i, h (t) i ) of N i, where the receivers in D(Ω i ) can decode the source symbols transmitted by all the senders in S(Ω i ). A scalar linear network code Φ (t) i can then be constructed for this multicast scenario. Let E i (v) and D i (d j ) denote the encoding matrices and decoding matrices in Φ (t) i respectively. We then combine the above linear network codes Φ (t) i ( i k) into a scalar linear network code Φ (t) for Ω over N (t) as follows: Each encoding matrix E(v) in Φ (t) is simply a concatenation of the encoding matrices E i (v) s; however, since each receiver d j D(Ω i ) only needs X(s j ), the decoding matrix D(d j ) in Φ (t) is a sub-matrix of D i (d j ) consisting of the columns corresponding to X(s j ). We refer to the above scalar linear network code Φ (t) as a multicast-packing code (MPC) for Ω over N (t) with respect to (G, H). Given r 0 R Ω 0, if there exists a sequence of MPCs with respect to (G, H), {Φ (tn) : n < }, such that lim n r(φ (tn) ) = r 0, we say that r 0 is achievable through MPC with respect to (G, H). Remark: In the construction of MPC, we can use the following method. We add a super sender s and link s to each s j S(Ω i ) via X(s j ) parallel edges, each of which has unit capacity and carries a distinct source symbol in X(s j ). Thus, we transform the multicast scenario with multiple multicast flows into a multicast scenario with a single multicast flow. Hence, we can employ the random approach of [4] or the (a) Fig. 2. An example of multicast-packing code over a 2-extension network. The network is shown in (a), where each edge has unit capacity, and 4 unicast flows coexist in the network. In (b), we show an MPC over a 2-extension network N (2) which achieves one half rate for each unicast flow. deterministic approach of [3] to construct linear network code for this multicast scenario. Example 2. Consider an example network as shown in Fig. 2. In this example, each edge has unit capacity, and four unicast flows coexist in the network, i.e., Ω = {ω i = (s i, d i ) : i 4}. We consider a partition G = {Ω = {ω, ω 2 }, Ω 2 = {ω 3, ω 4 }}. The allocation of network capacities is as follows. If e is an outgoing edge of s, s 2 or an incoming edge of d, d 2, h (e) = ; if e = (u, v), h (e) = 0.5; otherwise, h (e) = 0. If e is an outgoing edge of s 3, s 4 or an incoming edge of d 3, d 4, h 2 (e) = ; if e = (u, v), h 2 (e) = 0.5; otherwise, h 2 (e) = 0. An MPC with respect to (G, H) over the 2-extension network N (2) is shown in Fig. 2b. Clearly, this MPC achieves one half rate for each unicast flow. Proposition. The multicast-packing codes as shown in Fig. b and Fig. 2b achieve the maximal common rate. Proof: Appendix A. The choice of G and H is subject to various practical goals, which we explain in detail in Section IV-C. B. Achievability of Multicast-Packing Code In this section, we present the achievability properties of MPC for a given partition of the unicast flows. We first introduce the following concept. A S d flow over N is a function f : E R 0 which satisfies the following conditions: ) For each edge e E, 0 f(e) h(e). 2) For each node v V (S {d}), the following flow conservation law must be satisfied: e In(v) f(e) = e Out(v) f(e). The value of flow f at v S is defined as val(f, v) = e Out(v) f(e) e In(v) f(e). The following theorem fully characterizes the rate region achieved by MPCs with respect to (G, H). Theorem. Assume the size of finite field F 2 m is greater than Ω. Given a vector r = (r(s i ) : s i S(Ω)) R Ω 0, r is achievable through MPC with respect to (G, H) if and only if for each Ω i G and each d j D(Ω i ), there exists a S(Ω i ) d j flow f over N i = (V, E, h i ) such that val(f, s l ) = r(s l ) for each s l S(Ω i ). Proof: Appendix C. Example 2 - continued. Let us consider again the example provided in Fig. 2a to explain Theorem. For (b)

4 Ω i = Ω and d j = d, we construct a {s, s 2 } d flow f over N = (V, E, h ) as follows: For e {(s, u), (u, v), (v, d ), (s 2, d )}, f (e) = 0.5; otherwise, f (e) = 0. For Ω i = Ω and d j = d 2, we construct a {s, s 2 } d 2 flow f 2 as follows: For e {(s 2, u), (u, v), (v, d 2 ), (s, d 2 )}, f 2 (e) = 0.5; otherwise, f 2 (e) = 0. It is easy to see that val(f i, s j ) = 0.5 for i =, 2 and j =, 2. Similarly, we can verify the case for Ω i = Ω 2 and s j = d 3, d 4. This indicates that the MPC can achieve a common rate 2. C. Linear Program for MPC In this section, we formulate a linear program to calculate the performance achieved by MPCs for a given partition of the unicast flows. Theorem yields a set of linear constraints to describe the rate region achieved by multicast-packing code for a given partition G. In addition to Eq. (), we add the following linear constraints: For each Ω i G, d j D(Ω i ) and s l S(Ω i ), the value of the S(Ω i ) d j flow f at s l equals r(s l ): r(s l ) = e Out(s l ) f (e) e In(s l ) f (e). (2) For each Ω i G and d j D(Ω i ), f must satisfy the flow conservation law at each v V (S(Ω i ) {d j }): e Out(v) f (e) = e In(v) f (e). (3) For each Ω i G, d j D(Ω i ) and e E, 0 f (e) h i (e). (4) Remark: It can be easily seen that if each Ω i only contains one unicast flow, the above linear constraints are reduced to those of a routing scheme, in which each node only forwards the symbols it receives. Hence, routing can be viewed as a special case of MPC. In practice, the above constraints can be combined with additional constraints and various objectives to form a linear program. In this paper, we consider the following two objectives: Maximum common rate: We require that the transmission rate of each unicast flow must be at least a common rate r(g). In addition to Eq. () and Eq. (2)-(4), we add the following linear constraint for each s l S(Ω), The objective is simply: r(s l ) r(g). (5) Maximize r(g). (6) Minimum cost: We require that the transmission rate of each unicast flow ω l must be at least a fixed value q l. In addition to Eq. () and Eq. (2)-(4), we add the following constraint for each s l S(Ω), r(s l ) q l. (7) Let a : E R 0 be a function such that a(e) denotes the cost of occupying unit capacity along e. The objective is simply: Ω Minimize a(e)h i(e). (8) i= e E Remark: As it is seen, the allocation of network capacities H are decision variables in the above linear programs (see Eq. ()). Thus, the solution to these linear programs not only allows us to evaluate the performance achieved by multicastpacking code for a given partition G, but also includes H as part of the LP solution. From practical perspective, we only need to find the best partition G such that the MPC constructed from the LP solution achieves the best performance among all MPCs for Ω. Yet, when Ω becomes large, finding such partition as an LP solution is computationally expensive. Therefore, we present a practical partitioning algorithm based on simulated annealing techniques in the next section. V. SEARCHING FOR GOOD PARTITIONS In this section, we present a practical partitioning algorithm to approximate the best partition of Ω by employing simulated annealing technique [8]. The running process of the algorithm is divided into stages, each of which is associated with a positive temperature T. During each stage, it performs a random walk in the space of partitions of Ω. The probability that it moves from the current partition G to another partition G is { if r is better than r; P r(r, r, T ) = exp( κ r r T ) otherwise. where r, r denote the values of the objective function corresponding to G and G respectively. At the end of each stage, we reduce the temperature by a constant factor. Note that in case G is worse than G, there is still probability that the algorithm will move to G. This strategy prevents the algorithm from being stuck at a sub-optimal partition, which is typical of a greedy strategy. The algorithm consists of the following parts: ) Initialization (lines -4): The algorithm starts with a trivial partition G, in which each Ω i contains only one unicast flow ω i (line ). A LP solver is invoked to compute the solution (r, H) to the linear program constructed from G (line 2), where r denotes the value of the objective function, and H the allocation of network capacities included in the solution. Then, the temperature T is initialized to T 0 (line 4). 2) The for-loop (lines 5-22): The major body of the algorithm is the for-loop. Each iteration of the for-loop corresponds to a stage. The major body of the for-loop is a while-loop (lines 7-9). At the beginning of the while-loop, the algorithm calls a function get to generate a new partition G from G (line 8). The LP solver is invoked to compute the solution of the linear program constructed from G (line 9). If r is better than the best objective found previously, the algorithm records this better solution (lines 0-3). A function oracle is then called to decide if the algorithm moves to the new partition G (lines 4-7). At the end of the for-loop, the temperature is reduced by a factor (line 20). In the function get, the algorithm first randomly picks up two distinct subsets Ω i, Ω j, and a unicast session ω l Ω i. Then it moves ω l from Ω i to Ω j, and returns the resultant partition. Fig. 3 shows an example of the running process of the algorithm for the example of Fig. 2a. The algorithm starts from {{ω }, {ω 2 }, {ω 3 }, {ω 4 }}, and reaches the best partition {{ω, ω 2 }, {ω 3, ω 4 }} in three steps.

5 Algorithm : Algorithm to find good partition G {{ω i } : i Ω } ; // Initialize partition 2 (r, H) solve(g) ; // Solve LP 3 (r opt, H opt) (r, H); G opt G ; // Store the result 4 T T 0 ; // Setting initial temperature 5 for i to α do 6 j, k ; 7 while j β and k ζ do 8 G get(g) ; // Get a new partition from G 9 (r, H ) solve(g) ; // Solve LP 0 if r is better than r opt then (r opt, H opt) (r, H ); 2 G opt G ; 3 end 4 if oracle(r, r, T ) = true then 5 r r, G G ; // Move to the new partition 6 k k + ; // Record successful moves 7 end 8 j j + ; 9 end 20 T T η ; // Decrease temperature by a factor 2 end 22 return (r opt, H opt, G opt); 23 function get(g) 24 Select Ω i randomly from G; select ω l randomly from Ω i ; 25 Select Ω j randomly from G { } such that Ω i Ω j ; 26 Ω i Ω i {ω l }, Ω j Ω j {ω l }; 27 if Ω i is empty then G G {Ω i }; 28 return G; 29 function oracle(r, r, T ) 30 if r is better than r then return true; 3 Randomly select a number δ in the range [0, ]; 32 if δ < exp( κ r r ) then return true; T 33 else return false; Fig. 3. An example of the running process of the algorithm. The dashed lines denote the operations performed by the get function. For example, for the initial partition, the get function moves ω from {ω } to {ω 2 }, resulting in the partition {{ω, ω 2 }, {ω 3 }, {ω 4 }}. The algorithm reaches the best partition {{ω, ω 2 }, {ω 3, ω 4 }} from the initial partition in three steps. To deal with large scenarios, we divide the space of partitions of Ω into disjoint sub-spaces, and assign each of them to a dedicated processor. Then, these processors run the algorithm in parallel by randomly moving in the assigned sub-spaces. At last, we choose the best partition returned by these processors. A. Simulation Setup VI. EVALUATION We evaluate the performance of our approach via simulations. We used a network (see Fig. 4), which has been used by other researchers [8] [7], for our simulations. It has been shown by previous work [8] [7] that network coding exhibits better performance than routing only when shared bottlenecks are present. Thus, in our simulations, we focus on communication scenarios, where senders are separated from receivers by bottleneck links, e.g., e 5, e 6 and e 7, that have lower bandwidths and higher costs than other links. By changing the positions of senders and receivers, this network allows us to investigate the influence of the positions of Fig. 4. The network used for simulation. bottlenecks on the performance of MPCs. The the outgoing edges of a i s ( i 9) and the incoming edges of b i s all have infinite capacities and zero costs. Each multiple-unicast scenario Ω is a subset of {(a i, b j ) : i, j 9} such that the senders and the receivers are all distinct. We considered the cases where 3 Ω 7. For each setting of Ω, we randomly constructed 50 multiple-unicast scenarios. We considered two objectives, maximum common rate and minimum cost. For the first objective, we considered two capacity settings for the edges other than the outgoing edges of a i s and the incoming edges of b i s: Scenario : The edges all have unit capacities. Scenario 2: h(e 2 ) = h(e 5 ) = h(e 7 ) = 0.5, h(e 6 ) = 0.. The other edges have unit capacities. For the second objective, each edge has infinite capacity. We required that each unicast session must achieve at least unit rate. We considered two cost settings for the edges other than the outgoing edges of a i s and the incoming edges of b i s: Scenario 3: a(e ) = a(e 2 ) = a(e 3 ) = a(e 4 ) = 0, a(e 6 ) = 00. The other edges have unit costs. Scenario 4: a(e 3 ) = a(e 5 ) = a(e 7 ) = 0, a(e 6 ) = 00. The other edges have unit costs. Scenarios 2-4 model many practical transmission scenarios, where the end users are communicating with each other through long-distance links, which usually have limited bandwidths and higher costs than local links. The parameters for the simulated annealing algorithm were: T 0 = 0.5, α = 7, β = 92, ζ = 46, η = 0.9, κ = 7. We used GLPK 4.47 as the LP solver. All the simulations were run on a desktop computer with Intel core i3 CPU and 2GB memory. B. Simulation Results Let q m denote the objective obtained by the partitioning algorithm, q r the optimal objective achieved by routing, and λ succ the number of scenarios in which q m is better than q r. We define the following metrics to evaluate the results: Performance gain = qm qr q r 00%, Ratio of scenarios with gains = λsucc 50 00%. We averaged the performance gains over all scenarios with gains. The simulation results are shown in Table I. We make the following observations: ) Except for Scenario, the ratio of scenarios for which MPC achieves gains over routing all increases with Ω. Moreover, under Scenarios 2-4, MPC outperforms routing in almost half of the scenarios when Ω = 6, 7. Under Scenario 3, MPC outperforms routing for more than 60% of the scenarios when

6 Ω ratio of scenarios with gain time avg. avg. gains (%) (%) (sec) (a) Max. common rate, Scenario Ω ratio of scenarios with gain time avg. avg. gains (%) (%) (sec) (c) Min. cost, Scenario 3 TABLE I SIMULATION RESULTS. Ω ratio of scenarios with gain time avg. avg. gains (%) (%) (sec) (b) Max. common rate, Scenario 2 Ω ratio of scenarios with gain time avg. avg. gains (%) (%) (sec) (d) Min. cost, Scenario 4 Ω = 6, 7. For these scenarios, MPC is more scalable than routing in the sense that the chance of obtaining performance gains through MPC increases with Ω. 2) Under Scenarios -2, we observed that MPC achieves considerably better performance than routing for some scenarios. Under Scenario 2, MPC nearly doubles the performance of routing for the scenarios with gains. Under Scenarios 3-4, MPC still achieves a performance gain over routing ranging from 23% to 30% for the scenarios with gains. Since the ILPbased approach [7] converges very slow even for four unicast flows, we compare MPC with the evolutionary approach [8]. We consider the particular scenario presented in [8], where Ω = {(a, b 7 ), (a 2, b ), (a 7, b 2 ), (a 8, b 5 )} and the cost setting is the same as Scenario 3. For this scenario, MPC achieves a cost of 48, whereas the best cost achieved by the evolutionary approach over 30 runs of simulations is 56 [8]. 3) The simulated annealing algorithm is efficient in finding good partitions. For most scenarios, the running time of the algorithm never exceeds 7 seconds. This is mainly because the algorithm only needs to search in the space of the partitions of Ω. Note that, even for Ω = 5, the integer linear program in [7] contains around and 400 variables, and around and 700 constraints [8]. This makes the converging speed of the integer linear program very slow, and may fail to converge in a reasonable time [8]. In contrast, for Ω = 7 and G = 6, our linear program contains only 750 variables and 79 constraints, and each stage of the algorithm takes no more than 2 seconds for most scenarios. The evolutionary approach in [8] performs a random walk in the space of the coding vectors in the network. With each generation taking around one second, the total running time is around 00 seconds for 00 generations. In contrast, the simulated annealing algorithm preforms a random walk in the space of the partitions of Ω, which is much smaller than the space of the coding vectors. This greatly reduce the random steps the algorithm performs. The simulation results fully demonstrate the efficiency of the simulated annealing algorithm in finding good partitions. VII. CONCLUSION In this paper, we propose a novel approach, namely MPC, to construct linear network code for multiple-unicast scenario. We propose a set of linear constraints to describe the rate region achieved by MPC for a given partition of the multipleunicast scenario. These linear constraints can be combined with various objectives and additional constraints to form linear programs to calculate the performance achieved by MPC. The succinct formulation of these linear programs allow us to quickly analyze the performance of MPC. We further present a practical partitioning algorithm to find good partitions such that the resulting MPC approximates the best performance among all MPCs. Simulation results demonstrate the performance of MPC and the efficiency of the partitioning algorithm. As parts of our on-going work, we are investigating how to apply MPC to other problems related to network coding. For example, it can be shown that MPC can be used to solve the index coding problem, and provides the optimal solution for some instances of index coding problems. Moreover, it can also be applied to find network coding based protection schemes for networks where non-ergodic link failures may occur. APPENDIX A PROOF OF PROPOSITION To prove Proposition, we consider the general framework of network coding. Under this setting, each sender s i transmits a random variable X i. each edge (a, b) E transmits a random variable Y (a, b), which is a function of the random variables injected at a, i.e., H(Y (a, b) Z (a)) = 0. Meanwhile, Y (a, b) must abide by the capacity constraint, i.e., m H(Y (a, b)) h(a, b). Moreover, for each unicast flow ω i = (s i, d i ) Ω, the receiver d i must be able to decode the random variable s i transmits, i.e., H(X i Z (d i )) = 0. The transmission rate of ω i is defined as r(s i ) = m H(X i). Proof of Proposition : In the following proof, for simplicity, we use X[i : j] to denote the vector (X i, X i+,, X j ). For these two examples, we assume each unicast flow achieves a common rate r. Thus, for each unicast flow (s i, d i ), we have r r(s i ) = m H(X i) We first consider the example shown in Fig. a. Clearly, Y (s 2, d ) is a function of X 2, Y (s 3, d ) is a function of X 3, and Y (v, d ) is a function of (Y (e ), Y (e 2 )). Thus X is a a function of (Y (e ), Y (e 2 ), X 2, X 3 ). Hence, we have H(X Y (e ), Y (e 2 ), X[2 : 3]) = 0. Similarly, we can derive H(X 5 Y (e ), Y (e 2 ), X 4 ) = 0. Thus, the following equations hold: H(X[ : 5], Y (e ), Y (e 2 )) =H(Y (e ), Y (e 2 )) + H(X[2 : 3] Y (e ), Y (e 2 )) + H(X Y (e ), Y (e 2 ), X[2 : 3]) + H(X 4 Y (e ), Y (e 2 ), X[ : 3]) + H(X 5 Y (e ), Y (e 2 ), X[ : 4]) =H(Y (e ), Y (e 2 )) + H(X[2 : 3] Y (e ), Y (e 2 )) + H(X 4 Y (e ), Y (e 2 ), X[ : 3]) Meanwhile, due to H(Y (e ), Y (e 2 ) X[ : 5]) = 0, we have H(X[ : 5], Y (e ), Y (e 2 )) =H(X[ : 5]) + H(Y (e ), Y (e 2 ) X[ : 5]) =H(X[ : 5])

7 Hence, we can derive: 2m H(Y (e ), Y (e 2 )) =H(X[ : 5]) H(X[2 : 3] Y (e ), Y (e 2 )) H(X 4 Y (e ), Y (e 2 ), X[ : 3]) H(X[ : 5]) H(X[2 : 3]) H(X 4 ) =H(X ) + H(X 5 ) 2mr This indicates r. Since the MPC shown in Fig. b achieves a common rate of, this establishes the optimality of MPC for this example. Next, we consider the example shown in Fig. 2a. Similar to above, we can derive H(X Y (u, v), X 2 ) = 0, H(X 4 Y (u, v), X 3 ) = 0, and H(X[ : 4], Y (u, v)) = H(X[ : 4]). Meanwhile, the following equations hold: H(X[ : 4], Y (u, v)) =H(Y (u, v)) + H(X 2 Y (u, v)) + H(X Y (u, v), X 2 ) + H(X 3 Y (u, v), X[ : 2]) + H(X 4 Y (u, v), X[ : 3]) =H(Y (u, v)) + H(X 2 Y (u, v)) + H(X 3 Y (u, v), X[ : 2]) Hence, it follows that m H(Y (u, v)) =H(X[ : 4]) H(X 2 Y (u, v)) H(X 3 Y (u, v), X[ : 2]) H(X[ : 4]) H(X 2 ) H(X 3 ) =H(X ) + H(X 4 ) 2rm This implies that r 2. Since the MPC in Fig. 2b achieves a common rate 2, this establishes the optimality of MPC for this example. APPENDIX B PROOFS OF RESULTS ON FLOW THEORY A. Generalized Max-flow Min-Cut Theorem Given a node u V, let N + (u) denote the set of downstream neighbours of u. The set of edges from u to U N + (u) is denoted by E + (u, U). A S d cut is a partition (W, U) of V such that S W, d U, and W U = V. The cut-set of cut (W, U) is defined as C(W, U) = {e E : tail(e) W, head(e) U}. The capacity of cut (W, U) is defined as the capacity of its cutset. Let mincut(s, d, N ) denote the minimum capacity of all S d cuts over N. The following theorem provides an iterative approach to calculate mincut(u, v, N ). Given a set of edges E E, define c(e ) = e E h(e). If U =, we define mincut(u, v, N ) = 0. Lemma. Given two distinct nodes u, v V, let N = N + (u) {v}. The following equation holds: mincut(u, v, N ) = { h(e) + min h(e) U N e E + (u,v) e E + (u,u) } + mincut(n U, v, N ) Proof: Define the following subset of N : { U =argmin h(e) U N e E + (u,u) } + mincut(n U, v, N ) Denote U 2 = N U. Because the outgoing edges of u are not traversed by any path from U 2 to v, there exists a U 2 v cut-set E such that E N + (u) = and c(e ) = mincut(u 2, v, N ). Clearly, E 2 = E + (u, v) E + (u, U ) E forms a u v cut-set, the capacity of which is c(e 2 ) = c(e + (u, v)) + c(e + (u, U )) + c(e ) = h(e) + h(e) + mincut(u 2, v, N ) e E + (u,v) e E + (u,u ) Consider an arbitrary U v cut-set E 3. Apparently, E + (u, v) E 3. Denote U 3 = (E 3 E + (u, v)) Out(u) and W 3 = E 3 (E + (u, v) U 3 ). Since the removal of W 3 will break up every path from N U 3 to v, W 3 is also a (N U 3 ) v cut-set. Hence, it follows that c(w 3 ) mincut(n U 3, v, N ). This indicates that: c(e 3 ) = c(e + (u, v)) + c(u 3 ) + c(w 3 ) = h(e) + h(e) + c(w 3 ) e E + (u,v) e U 3 h(e) + h(e) + mincut(n U 3, d) e E + (u,v) e U 3 h(e) + h(e) + mincut(n U, d) e U e E + (u,v) = c(e 2 ) Thus, we have proved that c(e 2 ) = mincut(u, v, N ). This completes the proof. The following theorem can be seen as a generalized version of the Max-Flow and Min-cut Theorem. It can also be derived as a special case of a result by A. Frank regarding sub-modular flow (see Theorem 2..4 of [9]). Theorem 2. Given a function g : S R 0, there exists a S d flow f over N such that val(f, v) = g(v) for v S if and only if the following conditions are satisfied: g(v) mincut(u, d, N ) U S, U Proof: First, we prove the if part. Assume g satisfies the following condition: g(v) mincut(u, d, N ) U S, U We add a node s and connect it to each node v in U via an directed edge (s, v) with capacity g(v). Let N denote this network. Clearly, Out(s ) forms a s d cut-set and

8 c(out(s )) = v S g(v). According to Lemma, the following equation holds: mincut(s, d, N ) = min U S = min U S { { For U S, we have g(v) + mincut(s U, d, N ) g(v) + v S U } g(v) + mincut(s U, d, N ) } g(v) + mincut(s U, d, N ) g(v) = v S g(v) = c(out(s )) This indicates that c(out(s )) = mincut(s, d, N ). According to the Max-flow and Min-cut Theorem, there is a s d flow f over N such that val(f, s ) = c(out(s )) = g(v). Clearly, f (s, v) = g(v) for each v S. We then construct a S d flow f over N simply by setting f(e) = f (e) for each e E. Apparently, val(f, v) = g(v) for each v S. We next prove the only if part. Assume there is a S d flow f such that val(f, v) = g(v) for v S. Thus there exists a U d flow f such that val(f, v) = val(f, v) = g(v) for v U and val(f, v) = 0 for v S U. We then introduce a new node s and connect it to each node of U via a directed edge with infinite capacity. Let N = (V, E, h ) denote this new network. We then define a s d flow f 2 over N as follows: { val(f, head(e)) if head(e) U; f 2 (e) = f (e) otherwise. Due to the Max-flow and Min-cut Theorem, this suggests that g(v) = val(f, v) = val(f 2, s ) mincut(s, d, N ) = mincut(u, d, N ) This completes the proof. B. Rational Flow The concept of rational flow is essential in proving Theorem. Given a S d flow f over N, if f(e) Q for each e E, we say that f is a rational S d flow. According to the definition of a t-extension network N (t) of N, each edge e E corresponds to t h(e) parallel edges from tail(e) to head(e) in N (t). Let E (t) (e) denote the set of these parallel edges. The following lemma can be viewed as a generalized version of Menger s Theorem. Lemma 2. Assume that each edge e E has unit capacity. Let f be a S d flow over N such that val(f, v) N. Then, there exist v S val(f, v) disjoint directed paths from the nodes in S to d. Among these paths, there are exactly val(f, v) paths from each v S to d. Proof: We add a new node s and connect it to each v S via val(f, v) parallel edges, each with unit capacity. Let N = (V, E, h ) denote this network. We then define a s d flow f over N as follows: { if e Out(s); f (e) = f(e) otherwise. Thus, according to the Max-flow Min-cut Theorem, mincut(s, d, N ) = val(f, s). Hence, due to Menger s Theorem, there exist val(f, s) = v S val(f, v) disjoint paths from s to d. Moreover, since there are val(f, v) edges from s to each v S, there must be exactly val(f, v) paths from v to d among these paths. Lemma 3. Consider a t-extension network N (t) of N. Let f be a S d flow f over N (t) such that val(f, v) N for v S. Then, there exists a rational S d flow f over N such that val(f, v) = val(f,v) t. Proof: Due to Lemma 2, there exists a set P of v S val(f, v) disjoint paths from the nodes in S to d in N (t), among which there are exactly val(f, v) disjoint paths from each v S to d. For each e E, let k(e) denote the number of edges in E (t) (e) which are traversed by the paths in P. We then construct a S d flow f over N simply by setting f(e) = k(e) t for each e E. f is a rational S d flow over N, and for each v S, val(f, v) = val(f,v) t. Lemma 4. Let f be a S d flow such that val(f, v) Q for v S. If for each e E, h(e) Q, there exists a rational S d flow f over N such that val(f, v) = val(f, v). Proof: Because f is a S d flow, due to Theorem 2, the following inequalities must be satisfied: val(f, v) mincut(u, d, N ) U S, U Without loss of generality, let t be a positive integer such that tval(f, v) N for each v S and th(e) N for each e E. Consider the t-extension network N (t) = (V, E (t), h (t) ) of N. Clearly, mincut(u, d, N (t) ) = tmincut(u, d, N ). Hence, we have tval(f, v) mincut(u, d, N (t) ) U S, U By Theorem 2, this indicates that there is a S d flow f 2 over N (t) such that val(f 2, v) = tval(f, v) for v S. According to Lemma 3, this indicates that there exists a rational S d flow f over N such that for each v S, val(f, v) = val(f2,v) t = val(f, v). The following theorem states that each S d flow can be approximated by a sequence of rational S d flows. It will be used in the proof of Theorem. Lemma 5. Given a S d flow f, there exists a sequence of rational S d flows {f n : i < } such that lim n val(f n, v) = val(f, v) for each v S. Proof: If val(f, v) = 0 for each v S, we set f n = f and the lemma holds. In the rest of this proof, we assume there exists v S such that val(f, v) > 0. Due to Theorem

9 2, the following inequalities hold: val(f, v) mincut(u, d, N ) U S, U Thus, there must exist e E such that h(e) > 0. Let K be a positive integer such that < h(e) e E, h(e) > 0; K < val(f, v) v S, val(f, v) > 0 K For each integer n > K, we define a function h n : E R 0 as follows: If h(e) = 0, we set h n (e) = 0; otherwise, we set h n (e) to a rational number such that h(e) 2n E V h n(e) h(e) 4n E V Meanwhile, we define a function r n : S R 0 as follows: If val(f, v) = 0, we set r n (v) = 0; otherwise, we set r n (v) to a rational number such that val(f, v) n V r n(v) val(f, v) 2n V We consider the network ˆN n = (V, E, h n ). To avoid confusion, let c(w, T ) denote the capacity of a cut (W, T ) over N, and c n (W, T ) its counterpart over ˆNn. Let U be a non-empty subset of S. We now consider mincut(u, d, ˆN n ). We distinguish the following two cases: Case I: mincut(u, d, N ) = 0. Under the above definition of N n, we must have mincut(u, d, ˆN n ) = mincut(u, d, N ) = 0. Case II: mincut(u, d, N ) > 0. Let (W, T ) be a U d cut such that mincut(u, d, ˆN n ) = c n (W, T ). It follows: mincut(u, d, ˆN n ) = h n (e) e C(W,T ) h(e) e C(W,T ) C(W, T ) 2n E V mincut(u, d, N ) 2n V Meanwhile, let (W, T ) be a U d cut such that mincut(u, d, N ) = c(w, T ). Then, we have: mincut(u, d, ˆN n ) h n (e) e C(W,T ) h(e) =mincut(u, d, N ) e C(W,T ) 4n E V 4n E V We then consider r n(v). We distinguish the following cases: Case I: r n(v) = 0. It can be easily seen that: r n (v) mincut(u, d, ˆN n ) Case II: r n(v) > 0. We have: r n (v) val(f, v) 2n V mincut(u, d, N ) 2n V mincut(u, d, ˆN n ) Hence, according to Theorem 2 and Lemma 4, there exists a rational S d flow f n over ˆNn such that val(f n, v) = r n (v) for v S. Apparently, f n is also a rational S d flow over N. Due to the definition of r n (v), it must be that lim n val(f n, v) = val(f, v) for v S. This completes the proof. APPENDIX C PROOFS OF THEOREM In this appendix, we will prove Theorem. To facilitate our discussion, we first introduce the following concept of transfer matrix. Consider the multicast scenario constructed for Ω i G over the t-extension network N (t) i = (V, E (t) i, h (t) i ). Let X(Ω i ) denote the vector of the source symbols transmitted by all the senders in S(Ω i ). Following the same approach as [20], we regard each coding coefficient as a variable. These variables are grouped into a vector x i. At each receiver d j D(Ω i ), Z (d j ) = X(Ω i )M(d j ), where M(d j ) is called the transfer matrix at d j. Each element of M(d j ) is a polynomial in F 2 m[x i ]. [20]. Lemma 6. Consider the multicast scenario constructed for Ω i over N (t) i. If there exist X(Ω i ) disjoint paths from the nodes in S(Ω i ) to d j, among which there are exactly X(s l ) disjoint paths from each s l S(Ω i ) to d j, there must exist an X(Ω i ) X(Ω i ) sub-matrix M (d j ) of M(d j ) such that det(m (d j )) is a non-zero polynomial in F 2 m[x i ]. Proof: These disjoint paths yield a routing scheme, where each sender s l S(Ω i ) routes the source symbols in X(s l ) along the X(s l ) disjoint paths to d j. This routing scheme corresponds to an assignment of values to the coding coefficients, under which rank(m(d j )) = X(Ω i ). This indicates there must exist an X(Ω i ) X(Ω i ) sub-matrix M (d j ) of M(d j ) such that det(m (d j )) is a non-zero polynomial. We present the proof of Theorem as follows. Proof of Theorem : We first prove the only if part. Assume r = (r(s l ) : s l S(Ω)) can be achieved through multicast-packing with respect to (G, H). This suggests that there exists a sequence of multicast-packing codes with respect to (G, H), {Φ (kn) : n < }, such that lim n r(φ (kn) ) = r. Consider the multicast scenario for Ω i G over the k n -extension network N (kn) i = (V, E (kn) i, h (kn) i ) of N i. Let Φ (kn) i denote the scalar linear network code for this multicast scenario, and r n (s l ) the transmission rate achieved by Φ (kn) i for s l S(Ω i ). We add a super sender s i and link it to each s l S(Ω i ) via k n r n (s l ) parallel edges of unit capacities, each of which carries a distinct source (k symbol in X(s l ). Let ˆN n) i denote this extended network. We consider the multicast scenario Γ i = {(s i, D(Ω i))} where s i sends the source symbols in X(Ω i) to all the receivers in D(Ω i ). Clearly, there exists a linear network code for this multicast scenario. Hence, according to Theorem 4 of [20],

10 for each d j D(Ω i ), there must exist a s i d j flow ˆf over ˆN (kn) i such that val( ˆf, s i ) = s l S(Ω k i) nr n (s l ). Then, (n) we construct a S(Ω i ) d j flow ˆf over N (kn) i simply by setting (e) = ˆf (e) for each e E (kn). It is easy to ˆf (n) ˆf (n) see that val(, s l ) = k n r n (s l ) for each s l S(Ω i ). For each e E, let E (kn) i (e) denote the parallel edges in E (kn) i corresponding to e. We then define a S(Ω i ) d j flow f (n) over N i simply by setting f (n) (e) = i k n e E (kn) i (e) ˆf (n) for each e E. Apparently, val(f (n), s l ) = r n (s l ) for each s l S(Ω i ). We define a S(Ω i ) d j flow f over N i by setting f (e) = lim n f (n) (e). Clearly, val(f, s l ) = lim n r n (s l ) = r(s l ) for each s l S(Ω i ). Hence, we have proved the only if part. We next prove the if part. For each Ω i G and d j D(Ω i ), according to Lemma 5, there exists a sequence of S(Ω i ) d j rational flows {f (n) lim n val(f (n) (e) : n < } such that, s l ) = r(s l ) for each s l S(Ω i ). Let k n be a positive integer such that for all Ω i G, d j D(Ω i ), e E, and s l S(Ω i ), k n f (n) (e) N and k n val(f (n), s l ) N. We consider the multicast scenario constructed for Ω i over the k n - extension network N (kn) i of N i, where each sender s l S(Ω i ) transmits a vector X(s l ) of k n val(f (n), s l ) source symbols. The vector of the coding coefficients in N (kn) i is denoted by x (kn) i. (n) By Lemma 2, there are a n = k n s l S(Ω i) val(f, s l ) disjoint paths from the nodes in S(Ω i ) to d j, among which there are exactly k n val(f (n), s l ) disjoint paths from each s l S(Ω i ) to d j. Thus, due to Lemma 6, there must exist an a n a n sub-matrix M (d j ) of the transfer matrix M(d j ) such that det(m (d j )) is a non-zero polynomial in terms of x (kn) i. Hence, p(x (kn) i ) = d j D(Ω i) det(m (d j )) is also a non-zero polynomial. According to the result of [4], because the size of the finite field F 2 m is greater than Ω, we can find an assignment of values to x (kn) i, under which p(x (kn) i ) is evaluated to a non-zero value. Under this assignment, each transfer matrix M(d j ) has rank a n. Thus each receiver d j can decode X(Ω i ). This assignment corresponds to a scalar linear network code for the multicast scenario for Ω i. We combine these linear network codes into a multicast-packing code Φ (kn), which achieves a rate vector r(φ (kn) ) = (val(f (n), s l ) : s l S(Ω i ), Ω i G). Hence, we have constructed a sequence of multicast-packing codes with respect to (G, H), {Φ (kn) : n < }, such that lim n r(φ (kn) ) = r. Therefore, r can be achieved through multicast-packing with respect to (G, H). [4] T. Ho, M. Médard, R. Koetter, D. R. Karger, M. Effros, J. Shi, and B. Leong, A random linear network coding approach to multicast, IEEE Trans. on Information Theory, vol. 52, pp , [5] R. Dougherty, C. Freiling, K Zeger, Insufficiency of linear coding in network information flow, IEEE Trans. on Information Theory, vol. 5(8), Aug [6] A. R. Lehman and E. Lehman, Complexity classification of network information flow problems, in Proceedings of the fifteenth annual ACM- SIAM symposium on Discrete algorithms, pp , [7] D. Traskov, N. Ratnakar, D. S. Lun, R. Koetter, and M. Médard, Network coding for multiple unicasts: An approach based on linear optimization, in ISIT, pp , [8] M. Kim, M. Médard, U.-M. O Reilly, and D. Traskov, An evolutionary approach to inter-session network coding, in IEEE INFOCOM, [9] C. C. Wang and N. B. Shroff, Pairwise intersession network coding on directed networks, IEEE Trans. on Information Theory, vol. 56, pp , 200. [0] A. Khreishah, C.-C. Wang, and N. B. Shroff, Optimization based rate control for communication networks with inter-session network coding, in IEEE Infocom, [] J. Price and T. Javidi, Network coding games with unicast flows, IEEE Journal on Selected Areas in Communications, vol. 26, [2] S. Katti, H. Rahul, W. Hu, D. Katabi, M. Medard, and J. Crowcroft, Xors in the air: practical wireless network coding, IEEE/ACM Trans. on Networking (TON), vol. 6, pp , [3] S. Zhang, Y. Liu, M. Zhao, and W. Zhou, Improved GA solution on LNC coefficient matrix for multi-user cooperative communication, PIMRC, 202. [4] A. Das, S. Vishwanath, S. Jafar, and A. Markopoulou, Network Coding for Multiple Unicasts: An Interference Alignment Approach, ISIT, 200. [5] A. Ramakrishnan, A. Das, H. Maleki, A. Markopoulou, S. A. Jafar, and S. Vishwanath, Network Coding for Three Unicast Sessions: Interference Alignment Approaches, Allerton Conference, 200. [6] C. Meng, A. Ramakrishnan, A. Markopoulou, and S. A. Jafar,, On the Feasibility of Precoding-Based Network Alignment for Three Unicast Sessions, ISIT, 202. [7] S. Chen, O. Gunluk, and B. Yener, The multicast packing problem, IEEE/ACM Transactions on Networking, vol. 8, June [8] S. Kirkpatrick, C. D. Gelatt, Jr., and M. P. Vecchi, Optimization by simulated annealing, Science, vol. 220, pp , 983. [9] A. Frank, Connections in Combinatorial Optimization, Oxford Lecture Series in Math. and its Applications. Oxford University Press, 20. [20] R. Koetter and M. Médard, An algebraic approach to network coding, IEEE/ACM Transactions on Networking, vol., pp , Oct REFERENCES [] R. Ahlswede, N. Cai, S.-Y. R. Li, and R. W. Yeung, Network information flow, IEEE Trans. on Information Theory, vol. 46, pp , [2] S.-Y. R. Li, R. W. Yeung, and N. Cai, Linear network coding, IEEE Trans. on Information Theory, vol. 49, pp , [3] S. Jaggi, P. Sanders, P. A. Chou, M. Effros, S. Egner, K. Jain, and L. Tolhuizen, Polynomial time algorithms for multicast network code construction, IEEE Trans. on Information Theory, vol. 5, 2005.