Polynomial-time Capacity Calculation and Scheduling for Half-Duplex 1-2-1 Networks

Polynomial-time Capacity Calculation and Scheduling for Half-Duplex 1-2-1 Networks

Yahya H. Ezzeldin, Martina Cardone, Christina Fragouli, Giuseppe Caire UCLA, Los Angeles, CA 90095, USA, Email: {yahya.ezzeldin, christina.fragouli}@ucla.edu
University of Minnesota, Minneapolis, MN 55404, USA, Email: cardo089@umn.edu
Technische Universität Berlin, Berlin, Germany, Email: caire@tu-berlin.de
Abstract

This paper studies the 1-2-1 half-duplex network model, where two half-duplex nodes can communicate only if they point “beams” at each other; otherwise, no signal can be exchanged or interference can be generated. The main result of this paper is the design of two polynomial-time algorithms that: (i) compute the approximate capacity of the 1-2-1 half-duplex network and, (ii) find the network schedule optimal for the approximate capacity. The paper starts by expressing the approximate capacity as a linear program with an exponential number of constraints. A core technical component consists of building a polynomial-time separation oracle for this linear program, by using algorithmic tools such as perfect matching polytopes and Gomory-Hu trees.

I Introduction

Millimeter wave (mmWave) communication is expected to play an integral role in the Fifth Generation (5G) cellular technology, and to be used in a range of services, such as ultra-high resolution video streaming, vehicle-to-vehicle communication and intelligent buildings broadband coverage [1]. However, although a wide spectrum of promising applications has emerged fast, the focus of theoretical work has been mostly limited to single-hop systems. In this paper, we contribute to the fundamental understanding of networks of mmWave nodes building on our previous results in [2].

In [2], we recently introduced Gaussian 1-2-1 networks, a model that abstracts the directivity of mmWave beamforming. Using this model, we studied the Shannon capacity for arbitrary network topologies that consist of Full-Duplex (FD) mmWave nodes, that is, nodes that can receive and transmit at the same time using two highly directive beams. In particular, in [2] we showed that the capacity of a Gaussian 1-2-1 network with FD mmWave nodes can be approximated to within a universal constant gap111Constant gap refers to a quantity that is independent of the channel coefficients and operating SNR, and solely depends on the number of nodes. in polynomial-time in the network size. We term such approximation as approximate capacity in the remainder of the paper.

The focus of this paper is on Gaussian 1-2-1 networks with Half-Duplex (HD) nodes, that is, at any time instance, an HD node can either receive or transmit with a highly directive beam, but not both simultaneously. Our main results are as follows. We design a polynomial-time algorithm that enables to calculate the approximate capacity of a Gaussian HD 1-2-1 network with arbitrary topology. Additionally, we design an algorithm that computes the optimal schedule to achieve this approximate capacity in polynomial-time.

Fig. 1: Model of a 1-2-1 node (left) and an example of a 1-2-1 network with relays (right).

This is a surprising result: the approximate capacity of HD networks is notoriously hard to study. For a network with relays, since each node can either transmit or receive, there exist (an exponential number of) possible states. Thus, to calculate the approximate capacity, we may need to examine the fraction of time each of these states needs to be used. For instance, for the traditional Gaussian wireless network, although for FD networks the approximate capacity can be computed in polynomial-time in the network size [3], in HD such result is known to hold only for few special cases, such as line networks [4] and specific classes of layered networks [5]. Furthermore, although there have been several works that characterize the complexity of the optimal schedule for Gaussian HD wireless networks [6, 7], the problem of efficiently finding the schedule optimal for the approximate capacity for any general number of relays has only been solved for Gaussian line networks [4]. In this work, we show that the approximate capacity and an optimal schedule for Gaussian HD 1-2-1 networks can be always computed in polynomial-time in the network size, independently of the network topology.

Our result for HD 1-2-1 networks parallels our recent result for FD networks proved in [2]. However, the approach and tools we use here are different. In particular, we first show that the approximate capacity can be calculated as the solution of a linear program (LP) that has an exponential number of constraints. Then, we reduce our problem to building a polynomial-time separation oracle for this LP, by using graph-theoretic tools such as perfect matching polytopes [8] and Gomory-Hu trees [9].

Paper Organization. Section II describes the -relay Gaussian HD 1-2-1 network and presents some known capacity results for them. Section III presents our main results, which are proved in Section IV and Section V.

Ii System Model and Known Results

With we denote the set of integers from to ; is the empty set; is the indicator function; is the all-zero vector of length ; is the absolute value of when is a scalar, and the cardinality when is a set.

1-2-1 Gaussian HD network. We consider a network denoted by where relays assist the communication between a source node (node ) and a destination node (node ). We assume the following network model, which is shown in Fig. 1. At any time instant, this network has the two following features: (i) each node can direct/beamform its transmissions towards at most another node, and (ii) each node can point its receiving beam towards – and hence receive transmissions from – at most one other node. Moreover, the relays operate in HD mode, that is, at any particular time, each relay can be either transmitting to or receiving from at most one node.

In particular, we can mathematically model the features explained above, by introducing two discrete state random variables and , for each node . The variable (respectively, ) indicates the node towards which node is pointing its transmitting (respectively, receiving) beam. With this, we have that

(1a)
(1b)
(1c)

where since the source always transmits and the destination always receives, and where the constraint in (1c) follows since the relays operate in HD, i.e., for relay , if , then , and vice versa.

Thus, , we can write the input/output relationship for the Gaussian HD 1-2-1 network as

(2)

where: (i) represents the channel output at node ; (ii) is the channel coefficient from node to node ; the channel coefficients are assumed to remain constant for the entire transmission duration and hence they are known by all nodes in the network; (iii) is the additive white Gaussian noise at the -th node; noises across nodes in the network are assumed to be independent and identically distributed as ; (iv) has elements defined as

where is defined in (1), and where denotes the channel input at node ; the channel inputs are subject to an individual power constraint, i.e., ; note that, when node is not transmitting, i.e., , then ; (v) is defined in (1).

Capacity results on 1-2-1 networks. The Shannon capacity of the Gaussian HD 1-2-1 network described in (2) is not known. However, recently we have shown in [2, Theorem 1] that the capacity of the Gaussian HD (as well as FD) 1-2-1 network can be approximated by as follows222The expression in (3) holds for both HD and FD with different and different feasibility sets of the schedules .,

(3a)
(3b)
(3c)
(3d)

where: (i) enumerates all possible cuts in the graph representing the network, such that the source belongs to ; (ii) ; (iii) enumerates all possible network states of the 1-2-1 network in HD (or FD), where each network state corresponds to specific values for the variables in (1) for each HD node; (iv) , i.e., the optimization variable, is the fraction of time for which state is active; we refer to a schedule as the collection of for all feasible states, such that they sum up to at most 1; (v) and denote the transmitting and receiving states for node in the network state (defined in (1) for HD operation). In other words, for Gaussian HD 1-2-1 networks, in (3) is the approximate capacity of the Shannon capacity .

The expression in (3b) can be explained as follows. Given a fixed schedule , for each point-to-point link () in the network, we sum together the activation times of all the states that activate this link (represented by in (3b)). Then, we weight/multiply the link capacity by this effective activation time . For this new network with weighted link capacities as shown in (3b), we calculate the graph-theoretic min-cut. Finally, we maximize this min-cut over all possible feasible schedules of the 1-2-1 network.

Iii Main Results

In this section, we show how the expression of the approximate capacity in (3b) for Gaussian HD 1-2-1 networks can be efficiently evaluated and how an optimal schedule for (3b) can be found in polynomial-time in the number of network relays . In particular, our main result is summarized by the following theorem.

(a) 1-2-1 network with link activations.
(b) Network states in HD.
(c) Network states in FD.
Fig. 2: Gaussian 1-2-1 network examples and network states in HD and FD.
Theorem 1.

For the -relay Gaussian HD 1-2-1 network:

  1. The approximate capacity can be found in polynomial time in ;

  2. An optimal schedule for the approximate capacity can be found in polynomial-time in .

To the best of our knowledge, Gaussian HD 1-2-1 networks represent the first class of HD relay networks for which the approximate capacity and schedule can be computed efficiently independently of the network topology. In what follows, we focus on the proof of Theorem 1.

Theorem 1 Part (a). The proof of the first part of Theorem 1 is a direct consequence of two results that we present and discuss in what follows. Our first result shows that calculating for Gaussian HD 1-2-1 networks is equivalent to solving an LP, where state activation times are replaced by link activation times. In particular, we have the following theorem for which the proof is delegated to Appendix A.

Theorem 2.

For any -relay Gaussian HD 1-2-1 network, we have that

where represents the data flow through the link of capacity and represents the fraction of time in which the link is active.

Note that is very similar to the LP representation of the max-flow problem, where the edge capacities are given by . The key difference is that is now a variable and is subject to the feasibility constraints in that stem from the nature of the scheduling in HD 1-2-1 networks. Note that a similar LP as in Theorem 2 was obtained in [2] for the FD case. However, there is a fundamental difference in HD, which is captured by the constraints in that are not needed in FD. To illustrate the need of the constraint in in , consider the network in Fig. 1(a). Assume that each of the three links in the network is active for a fraction of time equal to (as shown in Fig. 1(a)). Clearly, these link activation times satisfy the constraint in with . However, we note that these link activation times do not satisfy the constraint in since, by considering , we have

Thus, if the constraint in was not there, then one would conclude that the link activation times illustrated in Fig. 1(a) are feasible. However, we now show that this is not the case, which highlights the need of the constraint in . For the Gaussian 1-2-1 network in Fig. 1(a), when the relay operates in HD, there are three possible useful states of the network, in each of which exactly one link is active. These three states are depicted with different line styles (i.e., solid, dashed, dotted) in Fig. 1(b). Note that the links and cannot be active simultaneously because of the HD constraint at the relay. Additionally, the links and cannot be activated simultaneously since the source has only a single transmitting beam. A similar argument also holds for the links and . Thus, for this network we have a one-to-one mapping between in (3b) and in , with if state activates the link of capacity . Hence, if we use the values from Fig. 1(a), we would obtain which clearly does not satisfy the constraint in (3b). We therefore conclude that the link activation times illustrated in Fig. 1(a), which are feasible if the relay operates in FD (see Fig 1(c)), are not feasible when the relay operates in HD. This simple example shows why the constraint in in is needed for HD Gaussian 1-2-1 networks.

We note that the LP has a number of variables that is polynomial in (two per each edge in the network) compared to the number of variables in the maximization in (3b), which instead is exponential in (one per each state in the network). However, we also note that now has an exponential number of constraints of the type . Thus, it follows that algorithms such as the simplex method and the interior point method can not solve in polynomial-time in . However, as we show next, the ellipsoid method [10] can indeed solve in polynomial-time in . The key step of the ellipsoid method, that incorporates the constraints of an LP, relies on the existence of an oracle which, given the problem and a point in space, can decide in polynomial-time whether the point is feasible or not and, if not, it returns one constraint of the linear program that is violated by that point. This is referred to as a polynomial-time separation oracle. Our next result focuses on showing that a polynomial-time separation oracle for exists such that, given the graph representing the -relay Gaussian HD 1-2-1 network and a point in the space of , it can verify in polynomial-time in if is feasible in and, if not feasible, it returns one of the constraints that is violated. In other words, if one of the constraints is violated, then the oracle returns a hyperplane that separates the point from the feasible polytope in . This result is formalized in the theorem below for which the proof is given in Section IV.

Theorem 3.

A polynomial-time separation oracle exists that, provided with a weighted graph with nodes and a point in the space of , can verify in polynomial-time in if is feasible in , and if not feasible it returns one of the constraints in that is violated.

Theorem 2, Theorem 3 and the existence of the ellipsoid method [10] directly imply the result in part (a) of Theorem 1.

Theorem 1 Part (b). The proof of the second part of Theorem 1 makes use of Theorem 3 and an algorithmic version of Caratheodory’s theorem to find a feasible schedule for the approximate capacity in (3b), such that each link is activated for the amount given by the solution of . Theorem 1 Part (b) is proved in Section V.

Iv Proof of Theorem 3

In this section, we prove Theorem 3, namely we show the existence of a polynomial time separation oracle that, provided with a weighted graph with nodes – representing our Gaussian HD 1-2-1 network – and a point in the space of , can verify in polynomial time in if is feasible in and if not, it returns a hyperplane that separates from the feasible region (i.e., an inequality satisfied for the feasible region but not for ).

Our oracle can be divided into two parts: (i) a simple oracle that checks the constraints in -, and (ii) a more involved oracle for checking the constraint in . Note that since the number of variables and constraints in - is polynomial in , then we can directly check these constraints for in polynomial time in . If one constraint is violated, then we return that constraint as the hyperplane that separates from the feasible set. In what follows, we prove that the constraint in can also be checked in polynomial time in . Towards this end, in Section IV-A we first overview some results from [8], and define the M-polytope and the Perfect Matching polytope (PM-polytope) of an undirected graph, and show a useful relationship between them. Note that (similar to the definition of the M-polytope), the PM-polytope of an undirected graph is the polytope that has all perfect-matchings333A perfect matching is a matching such that all vertices in the graph are connected to one edge in the matching set. as its extreme points. Then, in Section IV-B we show how a set that violates the constraint in can be found by first constructing a Gomory-Hu tree [9] of the weighted graph representing our network, and then checking cuts with a particular structure in it. Finally, in Section IV-C, we show how these results can be leveraged to build our polynomial time separation oracle.

Iv-a M-polytope and PM-polytope

We here overview some results from [8], and show a useful relationship between the M-polytope and the PM-polytope of an undirected graph, which we next define. In particular, we will use the following graph theory notation.

For an undirected graph , with set of vertices , set of edges and edge weight function , we use the convention with . Furthermore, in the remainder of this section, we use the definitions in Table I.

Quantity Definition
Weight corresponding to edge between nodes and
Set of edges in that have only one endpoint in the set of vertices
Set of edges with one endpoint in the set of vertices and the other endpoint in with
Set of edges with both endpoints in the set of vertices
Sum of the weights of the edges that belong to , i.e.,
TABLE I: Quantities of interest used throughout Section IV.
Fig. 3: Example of a weighted graph .

As an example of the used notation, with reference to the weighted graph in Fig. 3, we have

We let define the weighted undirected graph that describes our Gaussian HD 1-2-1 network, where is defined as in the constraint in in . Then, we note that the constraints in in are those introduced by Edmonds [8] to define the M-polytope for the graph . By using the notation introduced above, we can rewrite the constraints in in , as follows

(4)

The PM-polytope is represented similarly to the M-polytope, where now the second constraint in (4) is forced to be satisfied with equality, namely

(5)

By using the second constraint in (5), we can manipulate the third constraint, and rewrite the PM-polytope – see Appendix B for the detailed computation – as

(6)

We now show that, for any graph with vertices, there is an injection from the M-polytope of to the PM-polytope of a constructed graph with double the number of vertices. Towards this end, we first create a copy of the original graph and we let be a graph with: (i) , (ii) , and (iii) defined as

(7)

We now show that, if is in the M-polytope of , then is in the PM-polytope of . We start by noting that the given construction for in (7) satisfies the first two constraints in (6). The key challenge is to show that the third constraint is also satisfied, i.e.,

(8)

In Appendix C, we show that the constraint in (8) is indeed also satisfied. This result implies that we can check whether is in the M-polytope of by checking whether , with the construction in (7), is in the PM-polytope of .

Iv-B PM-polytope and Gomory-Hu tree

In the previous subsection, we have defined the PM-polytope for the weighted undirected graph as in (6). In particular, in (6) we can check in polynomial time if the first two sets of constraints are satisfied. Therefore, our main concern lies in the third group of constraints, since there is an exponential number of them. We here show that a set that violates the third constraint in (6) can be found by first constructing a Gomori-Hu tree [9] of (defined below), and then checking cuts with a particular structure in it.

We start by noting that the third group of constraints in (6) can be written in a compact way as

(9)

In words, what this says is that the minimum odd cut in has a value greater than or equal to 1. An odd cut is a vertex partition of into and such that either and/or has an odd cardinality ( is the complement of ).

In [11], Padberg and Rao provided an efficient algorithm to find the minimum odd cut and its value for any graph . An appealing feature of the algorithm designed in [11] is that it runs in polynomial time in . In particular, the method introduced consists of using Gomory-Hu trees.

Definition 1 (Gomory-Hu Tree).

Let be a capacitated (weighted) undirected graph with capacity function . A Gomory-Hu tree (for and ) is a capacitated tree with capacity , such that for each edge , the two components of give a a minimum capacity cut in . The capacity of the cut in is equal to .

Note that, for any capacitated undirected graph with vertices, a Gomory-Hu tree always exists and can be constructed by the algorithm in [9] using runs of the max-flow problem. Given the triangle inequality of min-cuts in a graph, Definition 1 implies the following property of Gomory-Hu trees.

Property 1.

Let be a capacitated undirected graph and be a Gomory-Hu tree of . Consider any two vertices , let be the path connecting and in and let be the edge with the minimum capacity along the path . Then, we have the two following properties:

  1. The two components give a minimum capacity cut in ;

  2. The value of the minimum capacity cut is given by .

Fig. 4: A Gomory-Hu tree of the graph in Fig. 3.

As an example of a Gomory-Hu tree, consider Fig. 4, which represents a Gomory-Hu tree of the graph in Fig. 3. From Property 1, it follows that if for in Fig. 3, we would like to know the minimum cut between vertices and , then all we need to do is to look at the unique path connecting and in in Fig. 4. The edge with the minimum capacity is and hence the min-cut between and equals . A cut that has this value in is the partition and .

We now state a simplified version of the result proved in [11] that shows how a Gomory-Hu tree of a graph can be leveraged to verify if the minimum odd cut of a graph satisfies (9). This theorem is proved in Appendix D.

Theorem 4.

Let be an undirected capacitated graph with even, and let be a Gomory-Hu tree for . Then, one of the cuts determined by , , is a minimum capacity odd cut in .

Thus, we can use the result in Theorem 4 to verify whether the minimum odd cut has a weight greater than or equal to one, by following the procedure illustrated in Algorithm 1. We note that in Algorithm 1, even though we need only one among and to be odd, in a graph with even number of vertices, if one is odd, then also the other is odd. This explains why we check if both and are odd.

In summary, we have here shown that we can find a set (if any) that violates the third constraint of the PM-polytope of defined in (6) by first constructing a Gomory-Hu tree and then checking odd cuts in it. Since the number of cuts in is , then by using this procedure we only need to perform checks (and not an exponential number of them).

1:function CheckMinimumOddCut()
2:     Build a Gomory-Hu tree of
3:     for each  do
4:         Let and be the two components of
5:         if  and are odd then
6:              if  then
7:                  return as the set that violates (9)                             return
Algorithm 1 Check if minimum odd cut in satisfies (9)

Iv-C Polynomial time separation oracle

We here show how the results that we discussed and stated in the previous two subsections can be combined and leveraged to build our polynomial time separation oracle. In particular, Algorithm 2 provides the pseudocode of our separation oracle. It is worth noting that each step in Algorithm 2 can be performed in polynomial time in and hence our oracle runs in polynomial time in . In particular, the complexity is dominated by the step where a Gomory-Hu tree is constructed for . This construction algorithm, in fact, involves performing the max-flow problem times and hence the complexity of this step – and consequentially of our oracle – is in the worst-case. This concludes the proof of Theorem 3.

1:Network NET, point to test for feasibility
2:Feasible flag, violated constraint in
3:Check if all constraints in - in are satisfied
4:if one constraint in - is violated then
5:     return Feasible = False, constraint violated
6:Construct undirected simple graph with the same set of nodes in NET, edges representing links in NET (but only one direction) and given by
7:Construct undirected graph from that has double number of vertices as described in Section IV-A
8: = CheckMinimumOddCut()
9:if  then
10:     return Feasible = True
11:else
12:     Feasible = False
13:     Let and
14:     Let be a copy of in
15:     Let be a copy of in
16:     if  odd then
17:         
18:     else
19:               
20:     return Feasible = False, constraint in violated
Algorithm 2 Polynomial time separation oracle for

V Finding a schedule in polynomial-time

To prove part (b) of Theorem 1, we first note that, for a Gaussian HD 1-2-1 network, a state in (3b) does not activate two adjacent links. Thus, a state is a matching of directed edges in a directed graph representing the network topology. Now, assume that we are given a feasible point in the LP (obtained by solving as described in Section IV). The main objective of this section is to efficiently construct a set of matchings (representing states in the network) and find their corresponding activation times (representing in (3b)), such that the fraction of time a link is active is equal to in . For any pair of nodes , we refer to in as the connection activation time, i.e., represents the duration of time nodes and are connected, without considering the direction of communication between them. Thus, from a connection activation time perspective, the network is represented by an undirected graph where an edge is active for a fraction of time. We first discuss how we can decompose the connection activation times into undirected matchings, and then show how these can be leveraged to construct our set of directed matchings (states). The goal is to show that both these tasks can be performed in polynomial-time in the number of relays .

V-a Decomposition into undirected matchings

We define the undirected graph , where: (i) the graph vertices in represent the nodes in our Gaussian HD 1-2-1 network, (ii) is the set of edges, and (iii) the edge weights are equal to the values of from the feasible point in . Note that, without loss of generality, in the definition of we do not include any edge for which .

Let be the vector comprised of . As highlighted in Section IV, the constraints on in describe the M-polytope of the undirected graph  [8]. Our goal here is to efficiently find a set of matchings (vertices of the M-polytope) such that

(10)

By Caratheodory’s theorem [12], we know that for some , such a decomposition of exists. However, the key challenge is to discover this decomposition in polynomial-time in . Towards this end, we appeal to a result in combinatorial optimization [13, Theorem 6.5.11]. This theorem states that, if we can optimize an objective function over the M-polytope using a separation oracle that runs in polynomial-time, then an algorithmic implementation of Caratheodory’s theorem can be performed in polynomial-time in the number of variables. Our result in Theorem 3 proves that such a polynomial-time separation oracle exists, and hence [13, Theorem 6.5.11] ensures that the decomposition in (10) can be performed in polynomial-time.

The remainder of this subsection is devoted to describing the decomposition algorithm [13, Theorem 6.5.11] and explaining why we can apply it to our M-polytope. For this, we need to explicitly mention some properties of polyhedra.

Definition 2.

The dimension of a polyhedron , is the maximum number of affinely independent points in minus 1. If , we say that is fully-dimensional. A polyhedron is said to bounded if there exists a ball in centered around the origin with radius such that .

Definition 3.

A polyhedron is called rational if all its vertices and at least one point in its interior belong to . A polyhedron is called well-described, if a finite number of bits is needed to encode a single constraint of the polyhedron.

Definition 4.

The subset is called a face of polyhedron , if there exists an inequality such that and . We say that the inequality defines the face .

Definition 5.

A face of polyhedron , is called a facet of if . If the polyhedron is fully-dimensional, then each non-redundant inequality constraint of defines a facet of .

It is not difficult to see that the M-polytope is rational, well-described and fully-dimensional. To see full-dimensionality, note that the set of matchings (vertices) such that each selects only one edge in the graph, together with the all-zero matching, form a set of affinely independent points with elements. As a result (by Definition 5) each constraint in  defines a facet of the M-polytope.

To describe the decomposition algorithm for our polytope, we need to shorthand two abstract oracles that we will use with their shorthand (SEP and OPT), extensively.

  1. denotes the separation oracle that takes a polyhedron and a point . This oracle determines if or else returns a constraint of that is violated by . If is fully-dimensional, then this returned constraint defines a facet of as aforementioned above. Note that might not be explicitly defined to the oracle with a set of constraints, but rather as an object (e.g., a graph) and a condition on the object (e.g., minimum odd cut is greater than some value). An example of such an oracle is the result in Theorem 3.

  2. denotes the optimization oracle that given a polyhedron and an affine objective function parameterized with , maximizes over . If is bounded then for any , the oracle returns a vertex of at which is maximized.

We are now ready to describe the algorithm used for the decomposition in (10) over the M-polytope. The exact details are described in Algorithm 3. The skeleton of Algorithm 3 is the following:

  1. We start with our desired point to decompose and find any vertex of the M-polytope (using OPT).

  2. Maximize along the line connecting and in the M-polytope in the direction . The maximizer, denoted as , is the intersection of the line and some boundary of the M-polytope. A simple illustration of , and is shown in Fig. 5.

  3. Since is in between and on a line, then we can write for .

  4. Next, we find a facet (defined as ) of the M-polytope containing by finding the constraint separating from the M-polytope for some (using SEP).

  5. We want to find a vertex of this facet so that we maximize the objective function (using OPT) to get a vertex in the .

  6. Since both and belong to then the line projected along them to get also belongs to .

  7. Repeat Steps 2) to 6) for until we hit a vertex in the end. Note that in Step 5) to get that belongs to the intersection of all facets , we use to ensure that the vertex satisfies .

  8. At the end, we have that for each ,

    Thus, by applying recursion, we can express our desired point as

    with

Fig. 5: An example of the decomposition of into and . The red color represents the facet that belongs to.
1:Graph
2:,
3:
4: = M-polytope of
5: // Set first objective function to any value (all ones here)
6:for each  do
7:      // Get vertex maximizing
8:     // Maximize in the direction of to get the point on the boundary of
9:     
10:     // Convex combination of and gets
11:      // Solve for :
12:     // Get the facet containing . Perturb by a small amount in the direction of to get a point outside of the polyhedron, and then apply the separation oracle.
13:      // defines a facet containing
14:     //We want the new vertex in the next iteration to be in the intersection of all facets visited before. This is done by adding all the inequalities defining these facets
15:     
16:for each  do
17:     
Algorithm 3 Decomposition into Caratheodory points

Note that Algorithm 3 above iterates over the oracles for a polynomial number of times equal to , since at each time, we are restricting our search with a new equation (), i.e., at every iteration we decrease the dimension of the currently considered polytope by 1. Therefore, if the oracles SEP and OPT can run in polynomial time, then the algorithm is polynomial in time. Fortunately, the M-polytope has a polynomial-time separation oracle (by Theorem 3) and a polynomial-time optimization oracle (by Theorem 1). Thus, by consequence Algorithm 2 runs in polynomial-time in the number of relay nodes .

V-B Post-processing for directional matchings

We now need to utilize the matchings and their activation times output by the algorithm discussed in the previous subsection to construct network states and find their activation times such that each link is activated for a duration (output by ). We can perform this decomposition in polynomial-time by iterating over the edges of the undirected graph constructed in the previous subsection. For notational ease, we can rewrite each of the matchings discovered in the previous subsection as a lower triangular matrix , where

where and are used since the matrix entries are matched with positive numbers while our nodes are indexed from . The rows of represent the receiving modules of the nodes, while the column indexes represent the transmitting modules of the nodes. As an illustrative example, consider a Gaussian HD 1-2-1 network with relays, where the undirected graph has edge set . For the matching shown below, we have the corresponding

1:Graph
2:,
3:
4:,
5:for each  do
6:     
7:     for each  do
8:         if  then
9:              if  then// All matchings that contain connection so far are less than
10:                  
11:              else if  then// All matchings that contain connection so far are exactly
12:                  // For all remaining matchings containing assign to
13:                  for each  do
14:                                          
15:                  
16:              else
17:                  // Make another copy () of the current state, and assign instead of
18:                   // Make a new copy at the end of the list
19:                  ,   
20:                  
21:                  // For all remaining matchings in containing assign to
22:                  for each