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

TL;DR

This paper introduces polynomial-time algorithms to approximate the capacity and determine optimal scheduling in 1-2-1 half-duplex networks, addressing the complexity of capacity computation with innovative algorithmic solutions.

Contribution

It presents the first polynomial-time algorithms for approximate capacity calculation and scheduling in 1-2-1 half-duplex networks, using advanced combinatorial optimization techniques.

Findings

Algorithms efficiently approximate network capacity.

Optimal schedules are computed in polynomial time.

The approach leverages perfect matching polytopes and Gomory-Hu trees.

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.

Tables

Table 1. TABLE I : Quantities of interest used throughout Section  IV .

Quantity	Definition
$x_G\left(e\right)$	Weight corresponding to edge $e=(i,j)$ between nodes $i\in V_G$ and $j\in V_G$
${\delta }_G\left(S\right)$	Set of edges in $G$ that have only one endpoint in the set of vertices $S\subseteq V_G$
$E_G(A,B)$	Set of edges with one endpoint in the set of vertices $A$ and the other endpoint in $B$ with $A,B\subseteq V_G$
$E_G\left(A\right)$	Set of edges with both endpoints in the set of vertices $A$
$x_G\left(F\right)$	Sum of the weights of the edges that belong to $F$, i.e., $x_G\left(F\right)=\sum _{e\in F}{x}_G\left(e\right)$

Equations

$$S_{i,t}\subseteq [1:N+1]\backslash \{i\},|S_{i,t}|\le 1,$$

$$S_{i,r}\subseteq [0:N]\backslash \{i\},|S_{i,r}|\le 1,$$

$$|S_{i,t}|+|S_{i,r}|\le 1,$$

$${\mathsf{C}}_{\mathrm{cs},\mathrm{iid}}\le \mathsf{C}\le {\mathsf{C}}_{\mathrm{cs},\mathrm{iid}}+\mathsf{GAP},$$

$${\mathsf{C}}_{\mathrm{cs},\mathrm{iid}}=\underset{\begin{array}{c}{\lambda }_s:{\lambda }_s\ge 0\\ {\sum }_s{\lambda }_s=1\end{array}}{\max }\underset{\Omega \subseteq [1:N]\cup \{0\}}{\min }\sum _{\begin{array}{c}(i,j):i\in \Omega ,\\ j\in {\Omega }^c\end{array}}\stackrel{{\ell }_{j,i}^{(s)}}{\overbrace{\underset{A_{ji}}{\underbrace{\left(\sum _{\begin{array}{c}s:\\ j\in s_{i,t},\\ i\in s_{j,r}\end{array}}{\lambda }_s\right)}}{\ell }_{j,i}}},$$

$${\ell }_{j,i}=\log \left(1+P{\left|h_{ji}\right|}^2\right),$$

$$\mathsf{GAP}=O(N\log N),$$

$$P1$$

$$(1a)0\le F_{j,i}\le {\lambda }_{ji}{\ell }_{j,i},\forall (i,j)\in [0:N]\times [1:N+1],$$

$$(1b)\sum _{j\in [1:N+1]\backslash \{i\}}{F}_{j,i}=\sum _{k\in [0:N]\backslash \{i\}}{F}_{i,k},i\in [1:N],$$

$$(1c){\hat{\lambda }}_{ij}={\lambda }_{ij}+{\lambda }_{ji},i\in [0:N],j\in [i+1:N+1],$$

$$(1d){\lambda }_{ij}\ge 0(i,j)\in [0:N]\times [1:N+1],$$

$$(1e)\sum _{\begin{array}{c}(i,j):i=v\mathrm{or}j=v,\\ i<j\end{array}}{\hat{\lambda }}_{ij}\le 1,\forall v\in [0:N+1],$$

$$(1f)\sum _{\begin{array}{c}i\in S,j\in S,\\ i<j\end{array}}{\hat{\lambda }}_{ij}\le \frac{|S|-1}{2},\forall S\subseteq [0:N+1],|S|\mathrm{odd},$$

$$(1g){\hat{\lambda }}_{ij}\ge 0i\in [0:N],j\in [i+1:N+1],$$

$$\sum _{\begin{array}{c}i\in S,j\in S,i<j\end{array}}{\hat{\lambda }}_{ij}={\hat{\lambda }}_{01}+{\hat{\lambda }}_{02}+{\hat{\lambda }}_{12}=\frac{3}{2}>\frac{|S|-1}{2}=1.$$

$${\delta }_G(\{1,3,4,5\})=\{(0,1),(1,2),(2,3),(2,4),(2,5)\},$$

$$E_G(\{1,3,4,5\},\{2\})=\{(1,2),(2,3),(2,4),(2,5)\},$$

$$E_G(\{1,3,4,5\})=\{(1,3),(1,4),(3,4),(3,5),(4,5)\},$$

$$x_G(\{(0,2),(1,3),(2,5)\})=8+4+2=14.$$

$$\displaystyle\begin{array}[]{ll}{\rm M-polytope}:&\\ \qquad\hat{\lambda}(e)\geq 0,&\forall e\in E_{G},\\ \qquad\hat{\lambda}(\delta_{G}(v))\leq 1,&\forall v\in V_{G},\\ \qquad\hat{\lambda}(E_{G}(S))\leq\dfrac{|S|-1}{2},&\forall S\subseteq V_{G},|S|\ \text{odd}.\end{array}$$

$$\displaystyle\begin{array}[]{ll}{\rm PM-polytope}:&\\ \qquad\hat{\lambda}(e)\geq 0,&\forall e\in E_{G},\\ \qquad\hat{\lambda}(\delta_{G}(v))=1,&\forall v\in V_{G},\\ \qquad\hat{\lambda}(E_{G}(S))\leq\dfrac{|S|-1}{2},&\forall S\subseteq V_{G},|S|\ \text{odd}.\end{array}$$

$$\displaystyle\begin{array}[]{ll}{\rm PM-polytope}:&\\ \qquad\hat{\lambda}(e)\geq 0,&\forall e\in E_{G},\\ \qquad\hat{\lambda}(\delta_{G}(v))=1,&\forall v\in V_{G},\\ \qquad\hat{\lambda}(\delta_{G}(S))\geq 1,&\forall S\subseteq V_{G},|S|\ \text{odd}.\end{array}$$

$$\tilde{\lambda }(e)=\{\begin{array}{ll}\hat{\lambda }(e)& \text{if }e\in E_G,\\ {\hat{\lambda }}^{\prime }(e)& \text{if }e\in E_{G^{\prime }},\\ 1-\hat{\lambda }({\delta }_G(v))& \text{if }e=(v,v^{\prime }).\end{array}$$

$$\tilde{\lambda }({\delta }_{\tilde{G}}(S))\ge 1,\forall S\subseteq V_{\tilde{G}},|S|\text{odd}.$$

$$\underset{\begin{array}{c}S\subseteq V_{\tilde{G}},\\ |S|\text{odd}\end{array}}{\min }\hat{\lambda }({\delta }_{\tilde{G}}(S))\ge 1.$$

$$\hat{\lambda }=\sum _{k=1}^K{\phi }_k{M}_k,\sum _{k=1}^K\phi =1,{\phi }_k\ge 0,\forall k\in [1:K].$$

$$y_{i-1}={\theta }_i{y}_i+(1-{\theta }_i)M_i,0\le {\theta }_i\le 1.$$

$$y_0=\sum _{i=1}^{|E_G|+1}{\phi }_i{M}_i,$$

$${\phi }_i={\theta }_i\prod _{j=1}^{i-1}(1-{\theta }_j).$$

$${\tilde{M}}_k(j,i)=\{\begin{array}{ll}{M}_k(e)& (i-1,j-1)\in E_G,i<j\\ 0& \text{otherwise},\end{array}$$

$$M_k=\left[\begin{array}{c}1\\ 0\\ 0\\ 0\\ 1\end{array}\right]⟹{\tilde{M}}_k=\left[\begin{array}{cccc}0& 0& 0& 0\\ 1& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 1& 0\end{array}\right].$$

$$\sum _{k=1}^{|E_G|+1}{\phi }_k{\tilde{M}}_k(j,i)={\hat{\lambda }}_{ij}\stackrel{(\text{P1})}{=}{\lambda }_{ji}+{\lambda }_{ij}.$$

$${\ell }_{j,i}^{(s)}=\left(\sum _{\begin{array}{c}s:\\ j\in s_{i,t},i\in s_{j,r}\end{array}}{\lambda }_s\right){\ell }_{j,i}.$$

$$P0$$

$$(0a)0\le F_{j,i}\le {\ell }_{j,i}^{(s)},\forall (i,j)\in [0:N]\times [1:N+1],$$

Full text

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.

This is a surprising result: the approximate capacity of HD networks is notoriously hard to study. For a network with $N$ relays, since each node can either transmit or receive, there exist $2^{N}$ (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 $N$ 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 $N$-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 $[n_{1}:n_{2}]$ we denote the set of integers from $n_{1}$ to $n_{2}\geq n_{1}$; $\emptyset$ is the empty set; $\mathds{1}_{P}$ is the indicator function; $0^{N}$ is the all-zero vector of length $N$; $|S|$ is the absolute value of $S$ when $S$ is a scalar, and the cardinality when $S$ is a set.

1-2-1 Gaussian HD network. We consider a network denoted by $\mathcal{N}$ where $N$ relays assist the communication between a source node (node [math]) and a destination node (node $N{+}1$). 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 $N$ 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 $S_{i,t}$ and $S_{i,r}$, for each node $i\in[0:N+1]$. The variable $S_{i,t}$ (respectively, $S_{i,r}$) indicates the node towards which node $i$ is pointing its transmitting (respectively, receiving) beam. With this, we have that

[TABLE]

where $S_{0,r}=S_{N+1,t}=\emptyset$ 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 $i\in[1:N]$, if $S_{i,t}\neq\emptyset$, then $S_{i,r}=\emptyset$, and vice versa.

Thus, $\forall j\in[1{:}N{+}1]$, we can write the input/output relationship for the Gaussian HD 1-2-1 network as

[TABLE]

where: (i) $Y_{j}\in\mathbb{C}$ represents the channel output at node $j$; (ii) $h_{ji}\in\mathbb{C}$ is the channel coefficient from node $i$ to node $j$; 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) $Z_{j}$ is the additive white Gaussian noise at the $j$-th node; noises across nodes in the network are assumed to be independent and identically distributed as $\mathcal{CN}(0,1)$; (iv) $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{i}\in\mathbb{C}^{N+1}$ has elements $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{i}(k)$ defined as

[TABLE]

where $S_{i,t}$ is defined in (1), and where $X_{i}\in\mathbb{C}$ denotes the channel input at node $i$; the channel inputs are subject to an individual power constraint, i.e., $\mathbb{E}[|X_{i}|^{2}]\leq P,\forall i\in[0:N]$; note that, when node $i$ is not transmitting, i.e., $S_{i,t}=\emptyset$, then $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{i}=0^{N+1}$; (v) $S_{j,r}$ 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 $\mathsf{C}$ of the Gaussian HD (as well as FD) 1-2-1 network can be approximated by $\mathsf{C}_{\rm cs,iid}$ as follows222The expression in (3) holds for both HD and FD with different $\mathsf{GAP}$ and different feasibility sets of the schedules $\{\lambda_{s}\}$.,

[TABLE]

where: (i) $\Omega$ enumerates all possible cuts in the graph representing the network, such that the source belongs to $\Omega$; (ii) $\Omega^{c}=[0:N+1]\backslash\Omega$; (iii) $s$ 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) $\lambda_{s}$, i.e., the optimization variable, is the fraction of time for which state $s$ is active; we refer to a schedule as the collection of $\lambda_{s}$ for all feasible states, such that they sum up to at most 1; (v) $s_{i,t}$ and $s_{i,r}$ denote the transmitting and receiving states for node $i$ in the network state $s$ (defined in (1) for HD operation). In other words, for Gaussian HD 1-2-1 networks, $\mathsf{C}_{\rm cs,iid}$ in (3) is the approximate capacity of the Shannon capacity $\mathsf{C}$.

The expression in (3b) can be explained as follows. Given a fixed schedule $\{\lambda_{s}\}$, for each point-to-point link ($i{\to}j$) in the network, we sum together the activation times $\lambda_{s}$ of all the states $s$ that activate this link (represented by $A_{ji}$ in (3b)). Then, we weight/multiply the link capacity $\ell_{j,i}$ by this effective activation time $A_{ji}$. For this new network with weighted link capacities $\ell_{j,i}^{(s)}$ 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 $\mathsf{C}_{\rm cs,iid}$ in (3b) for Gaussian HD 1-2-1 networks can be efficiently evaluated and how an optimal schedule $\{\lambda_{s}\}$ for (3b) can be found in polynomial-time in the number of network relays $N$. In particular, our main result is summarized by the following theorem.

Theorem 1**.**

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

1. (a)

The approximate capacity $\mathsf{C}_{\rm cs,iid}$ can be found in polynomial time in $N$; 2. (b)

An optimal schedule for the approximate capacity $\mathsf{C}_{\rm cs,iid}$ can be found in polynomial-time in $N$.

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 $\mathsf{C}_{\rm cs,iid}$ 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 $N$-relay Gaussian HD 1-2-1 network, we have that

[TABLE]

where $F_{j,i}$ represents the data flow through the link of capacity $\ell_{j,i}$ and $\lambda_{ji}$ represents the fraction of time in which the link is active.

Note that $\rm{P1}$ is very similar to the LP representation of the max-flow problem, where the edge capacities are given by $\lambda_{ji}\ell_{j,i}$. The key difference is that $\lambda_{ji}$ is now a variable and is subject to the feasibility constraints in $(1c)-(1f)$ 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 $(1f)$ that are not needed in FD. To illustrate the need of the constraint in $(1f)$ in $\rm{P1}$, consider the network in Fig. 2(a). Assume that each of the three links in the network is active for a fraction of time equal to $1/2$ (as shown in Fig. 2(a)). Clearly, these link activation times satisfy the constraint in $(1c){-}(1e)$ with $\hat{\lambda}_{01}{=}\hat{\lambda}_{02}{=}\hat{\lambda}_{12}=\frac{1}{2}$. However, we note that these link activation times do not satisfy the constraint in $(1f)$ since, by considering $S={\{}0{,}1{,}2{\}}$, we have

[TABLE]

Thus, if the constraint in $(1f)$ was not there, then one would conclude that the link activation times illustrated in Fig. 2(a) are feasible. However, we now show that this is not the case, which highlights the need of the constraint in $(1f)$. For the Gaussian 1-2-1 network in Fig. 2(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. 2(b). Note that the links $\mathsf{S}{\to}\mathsf{RN}$ and $\mathsf{RN}{\to}\mathsf{D}$ cannot be active simultaneously because of the HD constraint at the relay. Additionally, the links $\mathsf{S}{\to}\mathsf{RN}$ and $\mathsf{S}{\to}\mathsf{D}$ cannot be activated simultaneously since the source has only a single transmitting beam. A similar argument also holds for the links $\mathsf{RN}{\to}\mathsf{D}$ and $\mathsf{S}{\to}\mathsf{D}$. Thus, for this network we have a one-to-one mapping between $\lambda_{s}$ in (3b) and $\lambda_{ji}$ in $\rm{P1}$, with $\lambda_{s}=\lambda_{ji}$ if state $s$ activates the link of capacity $\ell_{j,i}$. Hence, if we use the values from Fig. 2(a), we would obtain $\sum_{s}\lambda_{s}=3/2>1$ which clearly does not satisfy the constraint in (3b). We therefore conclude that the link activation times illustrated in Fig. 2(a), which are feasible if the relay operates in FD (see Fig 2(c)), are not feasible when the relay operates in HD. This simple example shows why the constraint in $(1f)$ in $\rm{P1}$ is needed for HD Gaussian 1-2-1 networks.

We note that the LP $\rm{P1}$ has a number of variables that is polynomial in $N$ (two per each edge in the network) compared to the number of variables in the maximization in (3b), which instead is exponential in $N$ (one per each state in the network). However, we also note that $\rm{P1}$ now has an exponential number of constraints of the type $(1f)$. Thus, it follows that algorithms such as the simplex method and the interior point method can not solve $\rm{P1}$ in polynomial-time in $N$. However, as we show next, the ellipsoid method [10] can indeed solve $\rm{P1}$ in polynomial-time in $N$. 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 $\rm{P1}$ exists such that, given the graph representing the $N$-relay Gaussian HD 1-2-1 network and a point $y$ in the space of $\rm{P1}$, it can verify in polynomial-time in $N$ if $y$ is feasible in $\rm{P1}$ 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 $y$ from the feasible polytope in $\rm{P1}$. 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 $N+2$ nodes and a point $y$ in the space of $\rm{P1}$, can verify in polynomial-time in $N$ if $y$ is feasible in $\rm{P1}$, and if not feasible it returns one of the constraints in $\rm{P1}$ 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 $\lambda_{s}$ for the approximate capacity in (3b), such that each link is activated for the amount given by the solution of $\rm{P1}$. 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 $N+2$ nodes – representing our Gaussian HD 1-2-1 network – and a point $y\!=\!(F_{i,j},\lambda_{ij},\hat{\lambda}_{ij})$ in the space of $\rm{P1}$, can verify in polynomial time in $N$ if $y$ is feasible in $\rm{P1}$ and if not, it returns a hyperplane that separates $y$ from the feasible region (i.e., an inequality satisfied for the feasible region but not for $y$).

Our oracle can be divided into two parts: (i) a simple oracle that checks the constraints in $(1a)$-$(1e)$, and (ii) a more involved oracle for checking the constraint in $(1f)$. Note that since the number of variables and constraints in $(1a)$-$(1e)$ is polynomial in $N$, then we can directly check these constraints for $y$ in polynomial time in $N$. If one constraint is violated, then we return that constraint as the hyperplane that separates $y$ from the feasible set. In what follows, we prove that the constraint in $(1f)$ can also be checked in polynomial time in $N$. 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 $G$ 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 $S$ that violates the constraint in $(1f)$ 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 $G=(V_{G},E_{G},x_{G})$, with set of vertices $V_{G}$, set of edges $E_{G}$ and edge weight function $x_{G}:E_{G}\to\mathbb{R}$, we use the convention $e=(i,j)$ with $i<j$. Furthermore, in the remainder of this section, we use the definitions in Table I.

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

[TABLE]

We let $G=(V_{G},E_{G},\hat{\lambda})$ define the weighted undirected graph that describes our Gaussian HD 1-2-1 network, where $\hat{\lambda}(e)=\hat{\lambda}_{e}$ is defined as in the constraint in $(1c)$ in $\rm{P1}$. Then, we note that the constraints in $(1d)-(1f)$ in $\rm{P1}$ are those introduced by Edmonds [8] to define the M-polytope for the graph $G$. By using the notation introduced above, we can rewrite the constraints in $(1d)-(1f)$ in $\rm{P1}$, as follows

[TABLE]

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

[TABLE]

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

[TABLE]

We now show that, for any graph $G$ with $N$ vertices, there is an injection from the M-polytope of $G$ to the PM-polytope of a constructed graph $\widetilde{G}$ with double the number of vertices. Towards this end, we first create a copy $G^{\prime}=(V_{G^{\prime}},E_{G^{\prime}},\hat{\lambda}^{\prime})$ of the original graph $G$ and we let $\widetilde{G}=(V_{\widetilde{G}},E_{\widetilde{G}},\widetilde{\lambda})$ be a graph with: (i) $V_{\widetilde{G}}=V_{G}\cup V_{G^{\prime}}$, (ii) $E_{\widetilde{G}}=E_{G}\cup E_{G^{\prime}}\cup\{(v,v^{\prime})|v\in V_{G},\ v^{\prime}\ \text{is the copy of }v\text{ in }G^{\prime}\}$, and (iii) $\widetilde{\lambda}(e)$ defined as

[TABLE]

We now show that, if $\hat{\lambda}$ is in the M-polytope of $G$, then $\widetilde{\lambda}$ is in the PM-polytope of $\widetilde{G}$. We start by noting that the given construction for $\widetilde{\lambda}$ in (19) satisfies the first two constraints in (18). The key challenge is to show that the third constraint is also satisfied, i.e.,

[TABLE]

In Appendix C, we show that the constraint in (20) is indeed also satisfied. This result implies that we can check whether $\hat{\lambda}(e)$ is in the M-polytope of $G$ by checking whether $\widetilde{\lambda}(e)$, with the construction in (19), is in the PM-polytope of $\widetilde{G}$.

IV-B PM-polytope and Gomory-Hu tree

In the previous subsection, we have defined the PM-polytope for the weighted undirected graph ${\widetilde{G}}$ as in (18). In particular, in (18) 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 $S$ that violates the third constraint in (18) can be found by first constructing a Gomori-Hu tree [9] of ${\widetilde{G}}$ (defined below), and then checking cuts with a particular structure in it.

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

[TABLE]

In words, what this says is that the minimum odd cut in ${\widetilde{G}}$ has a value greater than or equal to 1. An odd cut is a vertex partition of $V_{\widetilde{G}}$ into $S$ and $S^{c}$ such that either $S$ and/or $S^{c}$ has an odd cardinality ($S^{c}$ is the complement of $S$).

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

Definition 1** (Gomory-Hu Tree).**

Let $G=(V_{G},E_{G},x_{G})$ be a capacitated (weighted) undirected graph with capacity function $x_{G}:E_{G}\to\mathbb{R}_{+}$. A Gomory-Hu tree (for $G$ and $x_{G}$) is a capacitated tree $T=(V_{G},F,\alpha_{T})$ with capacity $\alpha_{T}$, such that for each edge $e=(s,t)\in F$, the two components of $T\backslash e$ give a a minimum capacity $s-t$ cut in $G$. The capacity of the cut in $G$ is equal to $\alpha_{T}(s,t)$.

Note that, for any capacitated undirected graph with $N$ vertices, a Gomory-Hu tree always exists and can be constructed by the algorithm in [9] using $|V_{G}|-1$ 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 $G=(V_{G},E_{G},x_{G})$ be a capacitated undirected graph and $T=(V_{G},F,\alpha_{T})$ be a Gomory-Hu tree of $G$. Consider any two vertices $u,v\in V_{G}$, let $\mathcal{P}_{uv}$ be the path connecting $u$ and $v$ in $T$ and let $(s,t)$ be the edge with the minimum capacity $\alpha_{T}(s,t)$ along the path $\mathcal{P}_{uv}$. Then, we have the two following properties:

The two components $T\backslash(s,t)$ give a minimum capacity $u-v$ cut in $G$; 2. 2.

The value of the minimum capacity $u-v$ cut is given by $\alpha_{T}(s,t)$.

As an example of a Gomory-Hu tree, consider Fig. 4, which represents a Gomory-Hu tree $T$ of the graph $G$ in Fig. 3. From Property 1, it follows that if for $G$ in Fig. 3, we would like to know the minimum cut between vertices $1$ and $5$, then all we need to do is to look at the unique path connecting $1$ and $5$ in $T$ in Fig. 4. The edge with the minimum capacity is $(2,4)$ and hence the min-cut between $1$ and $5$ equals $13$. A cut that has this value in $G$ is the partition $U=\{0,1,2\}$ and $U^{c}=\{3,4,5\}$.

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 (21). This theorem is proved in Appendix D.

Theorem 4**.**

Let ${\widetilde{G}}=(V_{\widetilde{G}},E_{\widetilde{G}},\widetilde{\lambda})$ be an undirected capacitated graph with $|V_{\widetilde{G}}|$ even, and let $T=(V_{\widetilde{G}},F,\alpha_{T})$ be a Gomory-Hu tree for ${\widetilde{G}}$. Then, one of the cuts determined by $T\backslash e$, $\forall e\in F$, is a minimum capacity odd cut in ${\widetilde{G}}$.

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 $|W_{f}|$ and $|W_{f}^{c}|$ 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 $|W_{f}|$ and $|W_{f}^{c}|$ are odd.

In summary, we have here shown that we can find a set $S$ (if any) that violates the third constraint of the PM-polytope of ${\widetilde{G}}=(V_{\widetilde{G}},E_{\widetilde{G}},\widetilde{\lambda})$ defined in (18) by first constructing a Gomory-Hu tree $T=(V_{\widetilde{G}},F,\alpha_{T})$ and then checking odd cuts in it. Since the number of cuts in $T$ is $|V_{\widetilde{G}}|-1=2N+3$, then by using this procedure we only need to perform $O(N)$ checks (and not an exponential number of them).

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 $N$ and hence our oracle runs in polynomial time in $N$. In particular, the complexity is dominated by the step where a Gomory-Hu tree is constructed for ${\widetilde{G}}$. This construction algorithm, in fact, involves performing the max-flow problem $2N+3$ times and hence the complexity of this step – and consequentially of our oracle – is $O(N^{4})$ in the worst-case. This concludes the proof of Theorem 3.

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 $s$ 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 $\rm{P1}$ (obtained by solving $\rm{P1}$ 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 $\lambda_{s}$ in (3b)), such that the fraction of time a link $i{\to}j$ is active is equal to $\lambda_{ji}$ in $\rm{P1}$. For any pair of nodes $i<j$, we refer to $\hat{\lambda}_{ji}$ in $\rm{P1}$ as the connection activation time, i.e., $\hat{\lambda}_{ji}$ represents the duration of time nodes $i$ and $j$ 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 $(i,j)$ is active for a fraction $\hat{\lambda}_{ji}$ 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 $N$.

V-A Decomposition into undirected matchings

We define the undirected graph $G=(V_{G},E_{G},\hat{\lambda})$, where: (i) the graph vertices in $V_{G}$ represent the nodes in our Gaussian HD 1-2-1 network, (ii) $E_{G}=\{(i,j)|i>j,\ \hat{\lambda}_{ij}>0\}$ is the set of edges, and (iii) the edge weights are equal to the values of $\hat{\lambda}_{ij}$ from the feasible point in $\rm{P1}$. Note that, without loss of generality, in the definition of $E_{G}$ we do not include any edge $e$ for which $\hat{\lambda}_{e}=0$.

Let $\hat{\lambda}\in\mathbb{R}^{|E_{G}|}$ be the vector comprised of $\hat{\lambda}_{e},\ \forall e\in E_{G}$. As highlighted in Section IV, the constraints on $\{\hat{\lambda}_{e}\}$ in $(1e)-(1g)$ describe the M-polytope of the undirected graph $G$ [8]. Our goal here is to efficiently find a set of $K$ matchings ${M_{k}}\in\mathbb{R}^{|E_{G}|}$ (vertices of the M-polytope) such that

[TABLE]

By Caratheodory’s theorem [12], we know that for some $K{\leq}|E_{G}|{+}1$, such a decomposition of $\hat{\lambda}$ exists. However, the key challenge is to discover this decomposition in polynomial-time in $N$. 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 (22) 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 $P\subseteq\mathbb{R}^{n}$, $dim(P)$ is the maximum number of affinely independent points in $P$ minus 1. If $dim(P)=n$, we say that $P$ is fully-dimensional. A polyhedron $P$ is said to bounded if there exists a ball $B$ in $\mathbb{R}^{n}$ centered around the origin with radius $r<\infty$ such that $P\subseteq B$.

Definition 3**.**

A polyhedron $P\subseteq\mathbb{R}^{n}$ is called rational if all its vertices and at least one point in its interior belong to $\mathbb{Q}^{n}$. A polyhedron $P$ is called well-described, if a finite number of bits is needed to encode a single constraint of the polyhedron.

Definition 4**.**

The subset $F$ is called a face of polyhedron $P\subseteq\mathbb{R}^{n}$, if there exists an inequality such that $a^{T}x\leq a_{0},\ \forall x\in P$ and $F=\{x\in P|a^{T}x=a_{0}\}$. We say that the inequality $a^{T}x\leq a_{0}$ defines the face $F$.

Definition 5**.**

A face $F$ of polyhedron $P\subseteq\mathbb{R}^{n}$, is called a facet of $P$ if $dim(F)=dim(P)-1$. If the polyhedron $P$ is fully-dimensional, then each non-redundant inequality constraint of $P$ defines a facet of $P$.

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 $|E_{G}|+1$ elements. As a result (by Definition 5) each constraint in $(1e)-(1g)$ 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.

$SEP(P,y)$ denotes the separation oracle that takes a polyhedron $P$ and a point $y$. This oracle determines if $y\in P$ or else returns a constraint of $P$ that is violated by $y$. If $P$ is fully-dimensional, then this returned constraint defines a facet of $P$ as aforementioned above. Note that $P$ 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. 2.

$OPT(P,c)$ denotes the optimization oracle that given a polyhedron $P$ and an affine objective function parameterized with $c$, maximizes $c^{T}x$ over $x\in P$. If $P$ is bounded then for any $c$, the oracle returns a vertex of $P$ at which $c^{T}x$ is maximized.

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

We start with our desired point to decompose $y_{0}=\hat{\lambda}$ and find any vertex $M_{1}$ of the M-polytope (using OPT). 2. 2.

Maximize along the line connecting $y_{0}$ and $M_{1}$ in the M-polytope in the direction $y_{0}-M_{1}$. The maximizer, denoted as $y_{1}$, is the intersection of the line and some boundary of the M-polytope. A simple illustration of $y_{0}$, $y_{1}$ and $M_{1}$ is shown in Fig. 5. 3. 3.

Since $y_{0}$ is in between $M_{1}$ and $y_{1}$ on a line, then we can write $y_{0}=\theta_{1}M_{1}+(1-\theta_{1})y_{1}$ for $0\leq\theta\leq 1$. 4. 4.

Next, we find a facet $F_{1}$ (defined as $a_{1}^{T}x=b_{1}$) of the M-polytope containing $y_{1}$ by finding the constraint separating $y_{1}+\varepsilon(y_{0}-M_{1})$ from the M-polytope for some $\varepsilon>0$ (using SEP). 5. 5.

We want to find a vertex of this facet so that we maximize the objective function $c_{1}=a_{1}$ (using OPT) to get a vertex $M_{2}$ in the $F_{1}$. 6. 6.

Since both $y_{1}$ and $M_{2}$ belong to $F_{1}$ then the line projected along them to get $y_{2}$ also belongs to $F_{1}$. 7. 7.

Repeat Steps 2) to 6) for $i>1$ until we hit a vertex in the end. Note that in Step 5) to get $M_{i+1}$ that belongs to the intersection of all facets $F_{1},F_{2},\cdots,F_{i}$, we use $c_{i}=\sum_{j=1}^{i}a_{i}$ to ensure that the vertex satisfies $a_{j}^{T}x=b_{j},\ \forall j\in[1:i]$. 8. 8.

At the end, we have that for each $i\in[1:|E_{G}|+1]$,

[TABLE]

Thus, by applying recursion, we can express our desired point $y_{0}$ as

[TABLE]

with

[TABLE]

Note that Algorithm 3 above iterates over the oracles for a polynomial number of times equal to $|E_{G}|+1$, since at each time, we are restricting our search with a new equation ($a_{j}^{T}x=b_{j}$), 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 $N$.

V-B Post-processing for directional matchings

We now need to utilize the matchings $\{M_{k}\}$ and their activation times $\{\varphi_{k}\}$ output by the algorithm discussed in the previous subsection to construct network states and find their activation times such that each link $i{\to}j$ is activated for a duration $\lambda_{ji}$ (output by $\rm{P1}$). We can perform this decomposition in polynomial-time by iterating over the edges of the undirected graph $G$ constructed in the previous subsection. For notational ease, we can rewrite each of the matchings $M_{k}$ discovered in the previous subsection as a lower triangular matrix $\widetilde{M}_{k}\in\mathbb{R}^{(N+2)\times(N+2)}$, where

[TABLE]

where $i-1$ and $j-1$ are used since the matrix entries are matched with positive numbers while our nodes are indexed from [math]. The rows of $\widetilde{M}_{k}$ 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 $N=2$ relays, where the undirected graph $G$ has edge set $E_{G}=\{(0,1),(0,2),(1,2),(1,3),(2,3)\}$. For the matching $M_{k}$ shown below, we have the corresponding $\widetilde{M}_{k}$

[TABLE]

With this notation, we can design an algorithm that generates the $\{\lambda_{s}\}$ optimal for (3b) such that they collectively activate each link $i\to j$ for the duration $\lambda_{ji}$ output by the LP $\rm{P1}$. The formal procedure of the algorithm is described in Algorithm 4. The main idea behind Algorithm 4 is the following. From (22), the definition of $\widetilde{M}_{k}$ and the LP $\rm{P1}$, we know that $\forall(i,j)\in[0:N{+}2],$ such that $i<j$, we have

[TABLE]

Thus, for each connection $(i,j)$ in the network, we just need to break the matchings $\{\widetilde{M}_{k}\}$ into two sets contributing to the activation of the links $i\to j$ and $j\to i$. Before processing a connection $(i,j)$, the default direction is $i\to j$. The algorithm iterates over each connection $(i,j)$, and adds up the activation times for the matchings one by one until the sum exceeds $\lambda_{ji}$. For the remaining matchings, we change the assigned direction to $j\to i$. The matching $\widetilde{M}_{k}(j,i)$ that caused the sum to exceed $\lambda_{ji}$ is split into two copies, one where the direction is $i\to j$ and the other with $j\to i$.

Note that, in each iteration over the elements in $E_{G}$, we split at most one matching (state). Thus, starting with $|E_{G}|+1$ matchings, we end up with at most $2|E_{G}|+1$ matchings. Moreover, the inner loop iterates over at most $2|E_{G}|+1$ matchings. Thus, the algorithm runs in $O(|E_{G}|^{2})$ time which in the worst case is $O(N^{4})$ for a network with $N$ relays.

Appendix A Proof of Theorem 2

We start this section by taking note of an observation in [2], which states that, for a fixed $\lambda_{s}$, the inner minimization in $\mathsf{C}_{\rm cs,iid}$ in (3b) is the standard min-cut problem over a graph with link capacities given by

[TABLE]

We can therefore leverage the fact that the dual of the min-cut problem is the max-flow problem, and use strong duality to replace the inner minimization in (3b) with the max-flow problem over the graph with link capacities defined in (23). With this, we obtain

[TABLE]

where $F_{j,i}$ represents the flow from node $i$ to node $j$, and where the constraint in $(0b)$ ensures that flow is conserved at each relay node. Thus, to prove Theorem 2, we need to show that the linear program $\rm{P1}$ is equivalent to the linear program $\rm{P0}$.

We start by noting that all variables, except $\lambda_{s}$ and $\lambda_{ij}$, are the same in the two linear programs $\rm{P0}$ and $\rm{P1}$. Thus, to make $\rm{P0}$ and $\rm{P1}$ equivalent, we want to find a bijective mapping between $\lambda_{s}$’s and $\lambda_{ij}$’s.

If we observe a state $s$ in a Gaussian HD 1-2-1 network and hence in $\rm{P0}$, we see that a state does not activate two adjacent links, i.e., a state represents a matching444A matching in a graph is a set of graph edges such that each vertex (node) in the graph has at most one edge from the set connected to it. in the graph representing the network topology. Furthermore, the constraints in $(0a)$, $(0c)$ and $(0d)$ in $\rm{P0}$ suggest that the link activation times should be in the convex hull of the 0-1 activations representing a matching. To state this more formally, let $F$ be a matrix that is populated by the flow variables $F_{j,i}$ in $\rm{P0}$, and let $L$ be a matrix populated by the link capacities $\ell_{j,i}$ in $\rm{P0}$. For each state $s$, let $M_{s}$ be a binary matrix such that its $(j,i)$-th component is $1$ if the link from node $i$ to node $j$ is activated by state $s$, and [math] otherwise. Then, we can write the constraints in $(0a)$ and $(0c)$ in $\rm{P0}$ as

[TABLE]

where the operator $\odot$ denotes the element-wise multiplication (Hadamard product). Note that we made the sum of the state probabilities in (24b) equal to $1$, and this is without loss of generality. This is because one valid $M_{s}$ is populated by all zeros, and hence we can associate to this all-zero matrix a weight so that the sum equals $1$, without changing the main inequality in (24a). Now, if we consider $\rm{P1}$, then the constraint in $(1a)$ can be written as

[TABLE]

where $\Lambda$ is populated by the variables $\lambda_{ji}$.

From (24) and (25), we can see that the constraint needed in $\rm{P1}$ is to have $\Lambda$ in the convex hull of $\{M_{s}\}$, i.e., we want the link activations (or weights) that are in the convex hull of points representing matchings in a graphs. A result [8] by Edmonds for undirected graphs characterizes the constraints that represent the Matching polytope (M-polytope). The M-polytope of an undirected graph $G$ is the polytope that has all matchings as its extreme points. By massaging this result to apply to the directed graph in our problem, we define $\hat{\lambda}_{ij}=\lambda_{ij}+\lambda_{ji}$ for all $i<j$ and we apply Edmonds’s constraints on $\hat{\lambda}_{ij}$. With this, we precisely get the linear program in $\rm{P1}$. In particular, the M-polytope characterized by Edmonds defines the constraints in $(1e)$ and $(1f)$ on $\hat{\lambda}_{ij}$. The mapping from $\hat{\lambda}$ to $\lambda_{ij}$ is defined by the constraint in $(1c)$ in $\rm{P1}$. This concludes the proof of Theorem 2.

Appendix B Equivalence between PM-polytopes in (13) and (18)

We note that in (13) and (18), the first two constraints are the same. Thus, what we need to show is the equivalence between the third constraints in (13) and (18). In other words, given an undirected graph $G=(V_{G},E_{G},\hat{\lambda})$, with

[TABLE]

we want to show that for $\forall S\subseteq V_{G},|S|\ \text{odd}$, we have that

[TABLE]

A key property used to prove both directions is the fact that for any $S\subseteq V_{G}$, we have – by simple counting – that

[TABLE]

$\Longrightarrow$ direction: Let $S$ be an arbitrary subset of $V_{G}$ with odd cardinality. Then, we have that

[TABLE]

The above expression can be rewritten to give that $\hat{\lambda}(\delta_{G}(S))\geq 1$, which is precisely what we intended to show.

$\Longleftarrow$ direction: Let $S$ be an arbitrary subset of $V_{G}$ with odd cardinality. Then, we have that

[TABLE]

which, when reorganized, gives that $\hat{\lambda}(E_{G}(S))\leq(|S|-1)/2$. This concludes the proof that (13) and (18) are equivalent.

Appendix C Proof that $\widetilde{\lambda}$ in (19) satisfies (20)

We want to show that given $\hat{\lambda}$ in the M-polytope of $G$, then $\widetilde{\lambda}$ constructed as in (19) satisfies (20) – and hence it is in the PM-polytope of $\widetilde{G}$.

For any $S\subseteq V_{\widetilde{G}}$ we define $S_{a}=S\cap V_{G}$ and $S_{b}^{\prime}=S\cap V_{G^{\prime}}$. We let $S_{a}^{\prime}$ be the copy of $S_{a}$ in $V_{G^{\prime}}$ and similarly, we let $S_{b}$ be the copy of $S_{b}^{\prime}$ in $V_{G}$. Note that, $S=S_{a}\cup S^{\prime}_{b}$. Fig. 6 provides an illustration of these sets. We now consider two different cases for $S$ with odd cardinality and, for each of them, prove that the constraint in (20) is indeed satisfied. This will show that the construction of $\widetilde{\lambda}$ in (19) satisfies the constraint in (20).

Case 1: $S_{b}^{\prime}=\emptyset$. In this case, since $S=S_{a}\cup S^{\prime}_{b}$, then $|S|=|S_{a}|$ is odd, and we have that

[TABLE]

where: (i) the equality in $(a)$ follows by using counting arguments (see also (29) in Appendix B); (ii) the equality in $(b)$ follows from the fact that our construction of $\widetilde{\lambda}$ satisfies the second constraint in (18); (iii) the inequality in $(c)$ follows from the fact that, by our construction in (19) $\widetilde{\lambda}(E_{\widetilde{G}}(S_{a}))=\hat{\lambda}(E_{G}(S_{a}))$ and for any $S_{a}\subseteq V_{G}$, from the third constraint in (8), we have that $\hat{\lambda}(E_{G}(S_{a}))\leq\dfrac{|S_{a}|-1}{2}$. Thus, for this case the constraint in (20) is satisfied.

Case 2: $S_{b}^{\prime}\neq\emptyset$. We start by noting that (see also Fig. 6)

[TABLE]

Thus, since $|S|$ is odd, then one (and only one) among $|S_{a}\backslash S_{b}|$ and $|S_{b}^{\prime}\backslash S_{a}^{\prime}|$ is odd. Without loss of generality, assume that $|S_{a}\backslash S_{b}|$ is odd. Then, we have that (see also Fig. 6)

[TABLE]

where: (i) the equality in $(a)$ follows by defining

[TABLE]

(ii) the equality in $(b)$ follows by noting that $G^{\prime}$ is a copy of $G$ and hence $\widetilde{\lambda}(\delta_{\widetilde{G}}(Z))=\widetilde{\lambda}(\delta_{\widetilde{G}}(Z^{\prime}))$, $\widetilde{\lambda}\left(E_{\widetilde{G}}(S_{a}^{\prime}\backslash S_{b}^{\prime},Z^{\prime})\right)=\widetilde{\lambda}\left(E_{\widetilde{G}}(S_{a}\backslash S_{b},Z)\right)$ and similarly, $\widetilde{\lambda}\left(E_{\widetilde{G}}(S_{b}^{\prime}\backslash S_{a}^{\prime},Z^{\prime})\right)=\widetilde{\lambda}\left(E_{\widetilde{G}}(S_{b}\backslash S_{a},Z)\right)$; thus, with this, we have

[TABLE]

From the series of inequalities above, we have that

[TABLE]

Since we assumed, without loss of generality, that $|S_{a}\backslash S_{b}|$ is odd and by using similar arguments as in Case 1 (since $S_{a}\backslash S_{b}\subset V_{G}$), then it follows that

[TABLE]

Thus, for this case the constraint in (20) is satisfied.

The above analysis shows that, given $\hat{\lambda}$ in the M-polytope of $G$, then $\widetilde{\lambda}$, with the construction in (19), satisfies (20) – and hence it is in the PM-polytope of $\widetilde{G}$.

Appendix D Proof of Theorem 4

We here prove Theorem 4 – which is a simplified version of the result in [11] – by following the logic in [14, Theorem 25.6]. In particular, the goal of the proof is to show that, for any odd cut $U$ in the graph $\widetilde{G}$, we can always consider any Gomory-Hu tree $T$ of $\widetilde{G}$, and find an odd cut $W_{f^{\star}}$ inside it, such that $\delta_{\widetilde{G}}(U)\geq\delta_{\widetilde{G}}(W_{f^{\star}})$. Since this is true for all odd cuts, then it is also true for the minimum odd cut. This implies that one of the odd cuts in a Gomory-Hu tree is actually a minimum odd cut in $\widetilde{G}$. In the remainder of this appendix, we formalize this argument.

Let $T=(V_{\widetilde{G}},F,\alpha_{T})$ be a Gomory-Hu tree of the graph $\widetilde{G}=(V_{\widetilde{G}},E_{\widetilde{G}},\widetilde{\lambda})$, where we assume that $|V_{\widetilde{G}}|$ is even. Then, $\forall f\in F$, we let $W_{f}$ be one of the two components of $T\backslash f$. Let $U$ be an arbitrary odd cut in $\widetilde{G}$. Applying $U$ to the Gomory-Hu tree $T$ gives us $\delta_{T}(U)$, which we refer to as the cut-set of $U$, i.e., the set of edges that separate $U$ from $U^{c}$ in the Gomory-Hu tree $T$. Note that $\delta_{T}(W_{f})=f$. Thus, we have that

[TABLE]

where $A\Delta B$ is the symmetric difference between the sets $A$ and $B$, and where in $(a)$ we appeal to the property of cuts that for any two sets $S_{1},S_{2}\subset V_{\widetilde{G}}$, we have that

[TABLE]

Since cuts in a tree have unique cut-sets (excluding complements), then from (D), we have that

[TABLE]

Moreover, since $|V_{\widetilde{G}}|$ is even and, by assumption, $|U|$ is odd, then $|U^{c}|$ is also odd. Thus, in any case, we have that \left|\displaystyle\operatorname*{\text{\Large\Delta}}_{f\in\delta_{T}(U)}W_{f}\right| is odd. Finally, the last step in the proof is to appeal to the following property that relates the cardinality of two sets to their symmetric difference. For any two sets $A$ and $B$, we have that

[TABLE]

Thus, if $|A\Delta B|$ is odd, then either $|A|$ or $|B|$ is odd. This extends to the case, when we have $\Delta_{i=1}^{M}A_{i}$. In this case, at least one of the sets $A_{i}$ has an odd cardinality. Applying this observation to the set \displaystyle\operatorname*{\text{\Large\Delta}}_{f\in\delta_{T}(U)}W_{f}, we have that for some $f^{\star}\in\delta_{T}(U)$, $|W_{f^{\star}}|$ is odd.

Let $f^{\star}=(s,t)$ and recall that we assumed in our proof that the set $U$ is an arbitrary odd cut in $\widetilde{G}$. Moreover, the edge $f^{\star}$ belongs to both $\delta_{T}(W_{f^{\star}})$ and $\delta_{T}(U)$. Thus, both $U$ and $W_{f^{\star}}$ represent an $s-t$ cut in $\widetilde{G}$. From the definition of the Gomory-Hu tree (see Definition 1), $W_{f^{\star}}$ is a minimum cut for $s-t$. Thus, we have that

[TABLE]

Furthermore, since $|W_{f^{\star}}|$ is odd, then we have proved that, for any odd cut $U$ in $\widetilde{G}$, we can find one cut $W_{f^{\star}}$ in $T$ (cuts by removing one edge) that is odd and such that $\widetilde{\lambda}(\delta_{\widetilde{G}}(U))\geq\widetilde{\lambda}(\delta_{\widetilde{G}}(W_{f^{\star}}))$. This concludes the proof of Theorem 4.