Polynomialtime Capacity Calculation and Scheduling for HalfDuplex 121 Networks
Abstract
This paper studies the 121 halfduplex network model, where two halfduplex 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 polynomialtime algorithms that: (i) compute the approximate capacity of the 121 halfduplex 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 polynomialtime separation oracle for this linear program, by using algorithmic tools such as perfect matching polytopes and GomoryHu 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 ultrahigh resolution video streaming, vehicletovehicle 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 singlehop 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 121 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 FullDuplex (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 121 network with FD mmWave nodes can be approximated to within a universal constant gap^{1}^{1}1Constant gap refers to a quantity that is independent of the channel coefficients and operating SNR, and solely depends on the number of nodes. in polynomialtime 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 121 networks with HalfDuplex (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 polynomialtime algorithm that enables to calculate the approximate capacity of a Gaussian HD 121 network with arbitrary topology. Additionally, we design an algorithm that computes the optimal schedule to achieve this approximate capacity in polynomialtime.
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 polynomialtime 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 121 networks can be always computed in polynomialtime in the network size, independently of the network topology.
Our result for HD 121 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 polynomialtime separation oracle for this LP, by using graphtheoretic tools such as perfect matching polytopes [8] and GomoryHu trees [9].
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 allzero vector of length ; is the absolute value of when is a scalar, and the cardinality when is a set.
121 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 121 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 121 networks. The Shannon capacity of the Gaussian HD 121 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) 121 network can be approximated by as follows^{2}^{2}2The 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 121 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 121 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 pointtopoint 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 graphtheoretic mincut. Finally, we maximize this mincut over all possible feasible schedules of the 121 network.
Iii Main Results
In this section, we show how the expression of the approximate capacity in (3b) for Gaussian HD 121 networks can be efficiently evaluated and how an optimal schedule for (3b) can be found in polynomialtime in the number of network relays . In particular, our main result is summarized by the following theorem.
Theorem 1.
For the relay Gaussian HD 121 network:

The approximate capacity can be found in polynomial time in ;

An optimal schedule for the approximate capacity can be found in polynomialtime in .
To the best of our knowledge, Gaussian HD 121 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 121 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 121 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 maxflow 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 121 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 121 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 onetoone 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 121 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 polynomialtime in . However, as we show next, the ellipsoid method [10] can indeed solve in polynomialtime 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 polynomialtime 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 polynomialtime separation oracle. Our next result focuses on showing that a polynomialtime separation oracle for exists such that, given the graph representing the relay Gaussian HD 121 network and a point in the space of , it can verify in polynomialtime 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 polynomialtime separation oracle exists that, provided with a weighted graph with nodes and a point in the space of , can verify in polynomialtime 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 121 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 IVA we first overview some results from [8], and define the Mpolytope and the Perfect Matching polytope (PMpolytope) of an undirected graph, and show a useful relationship between them. Note that (similar to the definition of the Mpolytope), the PMpolytope of an undirected graph is the polytope that has all perfectmatchings^{3}^{3}3A 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 IVB we show how a set that violates the constraint in can be found by first constructing a GomoryHu tree [9] of the weighted graph representing our network, and then checking cuts with a particular structure in it. Finally, in Section IVC, we show how these results can be leveraged to build our polynomial time separation oracle.
Iva Mpolytope and PMpolytope
We here overview some results from [8], and show a useful relationship between the Mpolytope and the PMpolytope 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., 
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 121 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 Mpolytope for the graph . By using the notation introduced above, we can rewrite the constraints in in , as follows
(4) 
The PMpolytope is represented similarly to the Mpolytope, 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 PMpolytope – see Appendix B for the detailed computation – as
(6) 
We now show that, for any graph with vertices, there is an injection from the Mpolytope of to the PMpolytope 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 Mpolytope of , then is in the PMpolytope 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 Mpolytope of by checking whether , with the construction in (7), is in the PMpolytope of .
IvB PMpolytope and GomoryHu tree
In the previous subsection, we have defined the PMpolytope 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 GomoriHu 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 GomoryHu trees.
Definition 1 (GomoryHu Tree).
Let be a capacitated (weighted) undirected graph with capacity function . A GomoryHu 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 GomoryHu tree always exists and can be constructed by the algorithm in [9] using runs of the maxflow problem. Given the triangle inequality of mincuts in a graph, Definition 1 implies the following property of GomoryHu trees.
Property 1.
Let be a capacitated undirected graph and be a GomoryHu 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:

The two components give a minimum capacity cut in ;

The value of the minimum capacity cut is given by .
As an example of a GomoryHu tree, consider Fig. 4, which represents a GomoryHu 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 mincut 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 GomoryHu 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 GomoryHu 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 PMpolytope of defined in (6) by first constructing a GomoryHu 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).
IvC 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 GomoryHu tree is constructed for . This construction algorithm, in fact, involves performing the maxflow problem times and hence the complexity of this step – and consequentially of our oracle – is in the worstcase. This concludes the proof of Theorem 3.
V Finding a schedule in polynomialtime
To prove part (b) of Theorem 1, we first note that, for a Gaussian HD 121 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 polynomialtime in the number of relays .
Va Decomposition into undirected matchings
We define the undirected graph , where: (i) the graph vertices in represent the nodes in our Gaussian HD 121 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 Mpolytope of the undirected graph [8]. Our goal here is to efficiently find a set of matchings (vertices of the Mpolytope) 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 polynomialtime 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 Mpolytope using a separation oracle that runs in polynomialtime, then an algorithmic implementation of Caratheodory’s theorem can be performed in polynomialtime in the number of variables. Our result in Theorem 3 proves that such a polynomialtime separation oracle exists, and hence [13, Theorem 6.5.11] ensures that the decomposition in (10) can be performed in polynomialtime.
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 Mpolytope. 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 fullydimensional. 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 welldescribed, 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 fullydimensional, then each nonredundant inequality constraint of defines a facet of .
It is not difficult to see that the Mpolytope is rational, welldescribed and fullydimensional. To see fulldimensionality, note that the set of matchings (vertices) such that each selects only one edge in the graph, together with the allzero matching, form a set of affinely independent points with elements. As a result (by Definition 5) each constraint in defines a facet of the Mpolytope.
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.

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 fullydimensional, 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.

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 Mpolytope. The exact details are described in Algorithm 3. The skeleton of Algorithm 3 is the following:

We start with our desired point to decompose and find any vertex of the Mpolytope (using OPT).

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

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

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

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

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

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 .

At the end, we have that for each ,
Thus, by applying recursion, we can express our desired point as
with
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 Mpolytope has a polynomialtime separation oracle (by Theorem 3) and a polynomialtime optimization oracle (by Theorem 1). Thus, by consequence Algorithm 2 runs in polynomialtime in the number of relay nodes .
VB Postprocessing 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 polynomialtime 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 121 network with relays, where the undirected graph has edge set . For the matching shown below, we have the corresponding