On the Complexity of Local Graph Transformations

TL;DR

This paper studies the complexity of transforming one graph into another using local, node-based primitives, proving NP-hardness for optimal sequences and providing a polynomial-time approximation algorithm.

Contribution

It introduces a formal framework for local graph transformations, proves NP-hardness of finding minimal transformation sequences, and offers an efficient approximation algorithm.

Findings

Transforming graphs with local primitives is NP-hard.

A polynomial-time approximation algorithm with a constant ratio exists.

Local primitives cannot disconnect or add nodes to the graph.

Abstract

We consider the problem of transforming a given graph $G_s$ into a desired graph $G_t$ by applying a minimum number primitives from a particular set of local graph transformation primitives. These primitives are local in the sense that each node can apply them based on local knowledge and by affecting only its $1$-neighborhood. Although the specific set of primitives we consider makes it possible to transform any (weakly) connected graph into any other (weakly) connected graph consisting of the same nodes, they cannot disconnect the graph or introduce new nodes into the graph, making them ideal in the context of supervised overlay network transformations. We prove that computing a minimum sequence of primitive applications (even centralized) for arbitrary $G_s$ and $G_t$ is NP-hard, which we conjecture to hold for any set of local graph transformation primitives satisfying the aforementioned properties. On the other hand, we show that this problem admits a polynomial time algorithm with a constant approximation ratio.

Equations

$$AL{G}_1^2(G_s,G_t)$$

$$\le 8|F_{OPT,\oplus }|+7|E_{\oplus }|$$

$$\le 8OPT(U(G_s),U(G^{\prime }))+15|E_{\oplus }|$$

$$\le 23OPT(U(G_s),U(G^{\prime })),\text{ and}$$

$$AL{G}_2^2(G_s,G_t)$$

$$\le 8|F_{OPT,\ominus }|+4|E_{\ominus }|$$

$$\le 8OPT(U(G^{\prime }),U(G_t))+12|E_{\ominus }|$$

$$\le 20OPT(U(G^{\prime }),U(G_t)).$$

$$AL{G}^2(G_s,G_t):=$$

$$\le 23(2OP{T}_u(U(G_s),U(G_t))+|E_{\oplus }|)$$

$$\le 69OP{T}_u(U(G_s),U(G_t))$$

$$\le 69OP{T}_d(G_s,G_t).$$

Full text

This publication is the (revised) full version of a paper that appeared at ICALP’19 [DBLP:conf/icalp/ScheidelerS19].

1 Introduction

Overlay networks are used in many contexts, including peer-to-peer systems, multipoint VPNs, and wireless ad-hoc networks. In fact, any distributed system on top of a shared communication infrastructure usually has to form an overlay network (i.e., its participating sites have to know each other or at least some server) in order to allow its members to exchange information.

A fundamental task in the context of overlay networks is to maintain or adapt its topology to a desired topology, where the desired topology might either be pre-defined or depend on a certain objective function. The problem of reaching a pre-defined topology has been extensively studied in the context of self-stabilizing overlay networks (e.g., [29, 21, 12, 5, 22, 7]), and the problem of adapting the topology based on a certain objective function has been studied in the context of self-adapting and -optimizing overlay networks (e.g., [32, 14, 2, 19, 11, 3, 10, 8]). Many of these approaches are decentralized, and because of that, the work (in terms of number of edge changes) they need to adapt to a desired topology might be far away from the minimum possible work to reach that topology. In fact, no non-trivial results on the competitiveness of decentralized overlay network adaptations are known so far other than handling single join or leave operations, and it is questionable whether any good competitive result can be achieved with a decentralized approach. An alternative approach would be that a server is available for controlling the network adaptations, and this has already been considered in the context of so-called supervised overlay networks.

In a supervised overlay network there is a dedicated, trusted node called supervisor that controls all network adaptations but otherwise is not involved in the functionality of the overlay network (such as serving search requests), which is handled in a peer-to-peer manner. This has the advantage that even if the supervisor is down, the overlay network is still functional. Solutions for supervised overlay networks have been proposed in [24, 15], for example, and the results in [24] imply that, for specific overlay networks, any set of node arrivals and departures can be handled in a constant competitive fashion (concerning the work needed for adding and removing edges) to get back to a desired topology. But no general result is known so far for supervised overlay networks concerning the competitiveness of converting an initial topology into a desired topology. Also, no result is known so far on how to handle the problem that a supervisor could be faulty or even act maliciously.

A malicious supervisor would pose a significant problem for an overlay network since it could easily launch Sybil attacks (i.e., flooding the overlay network with fake or adversarial nodes) or Eclipse attacks (i.e., isolating nodes from other nodes in the overlay network). We thus ask: Can we limit the power of a supervisor such that it cannot launch an eclipse or sybil attack while still being able to convert the overlay network from any connected topology to any other connected topology?

We answer the question to the affirmative by determining a set of graph transformation commands, also called primitives, that only the supervisor may issue to the nodes. These primitives are powerful enough to transform any (weakly) connected topology into any other (weakly) connected topology but still allow the nodes to locally check that applying them does not disconnect the network or introduce a new node into the network. We additionally aim at minimizing the reconfiguration overhead, i.e., the number of commands to be issued (and, related to this, the number of changes to be made to node neighborhoods) to reach a desired topology. Unfortunately, as we will show, this cannot be done efficiently for the set of primitives we consider unless $\mathsf{P}\neq\mathsf{NP}$, and we conjecture that this holds for any set of commands that has the aforementioned property of giving the participants the ability to locally check that they cannot be used for eclipse or sybil attacks. However, we are able to give an $O(1)$-approximation algorithm for this problem.

1.1 Model and Problem Statement

We model the overlay network as a graph, i.e., nodes represent participants of the network and if there is a directed edge $(u,v)$ in the graph, this means that there is a connection from $u$ to $v$. Undirected edges $\{u,v\}$ model the two connections from $u$ to $v$ and from $v$ to $u$. Since there may be multiple connections between the same pair of participants, the graphs we consider in this work are multigraphs, i.e., edges may appear several times in the (multi-)set of edges. For convenience throughout this work we will use the term “graph” instead of multigraph and refer to “edge sets” even though their elements need not be unique.

We consider the following set $P_{d}$ of four primitives for the manipulation of directed graphs, first introduced by Koutsopoulos et al. [25] in the context of overlay networks:

Introduction

If a node $u$ has a reference of two nodes $v$ and $w$ with $v\neq w$, $u$ introduces $w$ to $v$ if $u$ sends a message to $v$ containing a reference of $w$ while keeping the reference.

Delegation

If a node $u$ has a reference of two nodes $v$ and $w$ s.t. $u,v,w$ are all different, then $u$ delegates $w$’s reference of $v$ if $u$ sends a message to $v$ containing a reference of $w$ and deletes the reference of $w$.

Fusion

If a node $u$ has two references $v$ and $w$ with $v=w$, then $u$ fuses the two references if it only keeps one of these references.

Reversal

If a node $u$ has a reference of some other node $v$, then $u$ reverses the connection if it sends a reference of itself to $v$ and deletes its reference of $v$.

The four primitives are visualized in Figure 1. Note that for the introduction primitive, it is possible that $w=u$, i.e., $u$ introduces itself to $v$. To simplify the description, we sometimes say that a node $u$ introduces or delegates the edge $(u,v)$ if $u$ introduces $v$ to some other node or delegates $v$’s reference to some other node, respectively.

The primitives in $P_{d}$ are known to be universal (c.f. [25]), i.e., it is possible to transform any weakly connected graph into any other weakly connected graph by using only the primitives in $P_{d}$. Note that for every edge $(u,v)$ used in any of the primitives, either $(u,v)$ still exists after the corresponding primitive is applied, or there is still an (undirected) path from $u$ to $v$ in the resulting graph. This directly implies that no application of the primitives can disconnect the graph. We assume that all connections are authorized, meaning that both endpoints are aware of the other endpoint of this connection. Thus, if for an edge $(u,v)$ that is supposed to be transformed into $(v,u)$ by an application of the reversal primitive, $v$ checks that $u$ actually was the previous endpoint of the former edge then the primitives cannot be used to introduce new nodes into the graph.

For undirected graphs, consider the set $P_{u}$ containing only the primitives introduction, delegation and fusion (defined correspondingly). These three primitives, accordingly, are universal on undirected graphs, i.e., any connected undirected graph can be transformed into any other connected undirected graph by applying the primitives in $P_{u}$ (c.f. [25]).

We make the following observation:

Observation 1**.**

The introduction primitive is the only primitive that can increase the number of edges in a graph. The fusion primitive is the only primitive that can decrease the number of edges in a graph. The delegation primitive is the only primitive that can remove the last edge between two nodes (i.e., an edge of multiplicity one).

A computation $C$ is a finite sequence $G_{1}\Rightarrow G_{2}\Rightarrow\dots\Rightarrow G_{l}$ of either directed or undirected graphs, in which each graph $G_{i+1}$ is obtained from $G_{i}$ by the application of a single primitive from $P_{d}$ or $P_{u}$, respectively. The graphs $G_{1}$ and $G_{l}$ are called the initial and the final graphs of $C$, respectively. The variable $l$ is called the length of the computation.

We define the Undirected Local Graph Transformation Problem (ULGT) as follows: given two connected undirected graphs $G_{s},G_{t}$, find a computation of minimum length whose initial graph is $G_{s}$ and whose final graph is $G_{t}$. The corresponding decision problem k-ULGT is defined as follows: given a positive integer $k$ and two connected undirected graphs $G_{s}$ and $G_{t}$, decide whether there is a computation with initial graph $G_{s}$ and final graph $G_{t}$ of length at most $k$. Accordingly we define the Directed Local Graph Transformation Problem (DLGT) and k-DLGT, which differ from the according problems in that the graphs are directed.

1.2 Related Work

Graph transformations have been studied in many different contexts and applications, including but not limited to pattern recognition, compiler construction, computer-aided software engineering, description of biological developments in organisms, and functional programming languages implementation (for a more detailed introduction and literature overview, we refer the reader to [4], [20], or [31, 13]). Simply put, a graph transformation (or graph-rewriting) system consists of a set of rules $L\rightarrow R$ that may be applied to subgraphs isomorphic to $L$ of a given graph $G$ thus replacing $L$ with $R$ in $G$. Since changing the labels assigned to a graph (graph relabeling) is also a kind of graph transformation, basically every distributed algorithm can be understood as a graph transformation system (c.f. [13]). The type of graph transformations probably closest related to our work is the area of Topology Control (TC). In simple terms, the goal of TC is to select a subgraph of a given input graph that fulfills certain properties (such as connectivity) and optimizes some value (such as the maximum degree). This problem has been studied in a variety of settings (for surveys on this topic see, e.g., [27], or [6]) and although the usual approach is decentralized, there are also some centralized algorithms in this area (see, e.g., [30]). However, these works only consider the complexity of computing an optimal topology (instead of the complexity of transforming the graph by a minimum number of rule applications). There is one work by Lin [28] proving the $\mathsf{NP}$-hardness of the Graph Transformation Problem, in which the goal is to find the minimum integer $k$ such that an initial graph $G_{s}$ can be transformed into a final graph $G_{t}$ by adding and removing at most $k$ edges in $G_{s}$. Our work differs from that work in that we do not allow arbitrary edge relocations but restrict them to a set of rules that can be applied locally (and we also provide constant-factor approximation algorithms).

Our approximation algorithms use an approximation algorithm for the Undirected Steiner Forest Problem as a black-box (also known as the Steiner Subgraph Problem with edge sharing, or, in generalizations, the Survivable Network Design Problem or the Generalized Steiner Problem). 2-approximations of this problem were first given by Agrawal, Klein, and Ravi [1], and by Goemans and Williamson [16], and later also by Jain [23]. Gupta and Kumar [18] showed a simple greedy algorithm to have a constant approximation ratio and recently, Groß et al. [17] presented a local-search constant approximation for Steiner Forest.

1.3 Our Contribution

The main contributions of this paper are as follows: We prove the Undirected and the Directed Local Graph Transformation Problem to be $\mathsf{NP}$-hard in Section 2. Furthermore, in Section 3 we show that they belong to $\mathsf{APX}$, i.e., there exist constant approximation algorithms for these two problems.

2 $\mathsf{NP}$-hardness results

In this section, we show the $\mathsf{NP}$-hardness of the Undirected Local Graph Transformation Problem by proving the $\mathsf{NP}$-hardness of k-ULGT (see Section 2.1). Since k-DLGT’s $\mathsf{NP}$-hardness is very similar for k-ULGT, we only briefly sketch the differences in Section 2.2. Throughout this section, for any positive integer $i$ we use the notation $[i]$ to refer to the set $\{1,2,\dots,i\}$.

2.1 k-ULGT is $\mathsf{NP}$-hard

We prove k-ULGT’s hardness via a reduction from the Boolean satisfiability problem ($\mathsf{SAT}$) which was proven to be $\mathsf{NP}$-hard by Cook [9] and, independently, by Levin [26]. We briefly recap $\mathsf{SAT}$ as follows:

Definition 2.1** ($\mathsf{SAT}$).**

Given a set $X$ of $n$ Boolean variables $x_{1},\dots,x_{n}$ and a Boolean formula $\Phi$ over the variables in $X$ in conjunctive normal form (CNF), decide whether there is a truth assignment $t:X\rightarrow\{0,1\}$ that satisfies $\Phi$.

To reduce $\mathsf{SAT}$ to k-ULGT, we use the following reduction function:

Definition 2.2** (Reduction function for $SAT\leq_{p}\textsc{k-ULGT}$).**

Let $S=(X,\Phi)$ be a $\mathsf{SAT}$ instance, in which $X=\{x_{1},\dots,x_{n}\}$ is the set of Boolean variables and $\Phi=C_{1}\land\dots\land C_{m}$ for clauses $C_{1},\dots,C_{m}$. Then $f(S)=(G_{s},G_{t},k)$ in which $k=2n+m$ and $G_{s}$ and $G_{t}$ are undirected graphs defined as follows. Without loss of generality, assume that each literal $y_{i}\in\{x_{i},\overline{x_{i}}\}$ occurs only once in each clause.

We define the following sets of nodes: $V_{C}=\{C_{1},\dots,C_{m}\}$, and $V_{X_{i}}=\{x_{i},\overline{x_{i}},s_{i},t_{i}\}$. Then, the set of nodes of $G_{s}$ and $G_{t}$ is $V=\bigcup_{1\leq i\leq n}V_{X_{i}}\cup V_{C}\cup\{r\}$. For the set of edges, define $E_{X_{i}}=\{\{s_{i},x_{i}\},\{s_{i},\overline{x_{i}}\},\{x_{i},t_{i}\},\{\overline{x_{i}},t_{i}\}\}$ for every $i\in[n]$, $E_{C_{j}}=\{\{y_{i},C_{j}\}|y_{i}\in\{x_{i},\overline{x_{i}}\}\land y_{i}\text{ occurs in }C_{j}\}$ for every $j\in[m]$, $E_{sr}=\{\{s_{i},r\}|1\leq i\leq n\}$, $E_{tr}=\{\{t_{i},r\}|1\leq i\leq n\}$, $E_{Cr}=\{\{C_{j},r\}|1\leq j\leq m\}$. Both $G_{s}$ and $G_{t}$ have the edges in $\bigcup_{1\leq i\leq n}E_{X_{i}}\cup\bigcup_{1\leq j\leq m}E_{C_{j}}$. Additionally, $G_{s}$ has the edges in $E_{sr}$ and $G_{t}$ has the edges in $E_{tr}\cup E_{Cr}$.

Intuitively, each variable $x_{i}$ is mapped to a gadget $X_{i}$ consisting of the four nodes $x_{i},\overline{x_{i}},s_{i}$, and $t_{i}$. Also each clause $C_{j}$ is connected with each literal occurring within it. Lastly, in $G_{s}$, each of the $s_{i}$ is connected with the node $r$, whereas in $G_{t}$, each of the $t_{i}$ and each of the $C_{j}$ are connected with $r$. Figure 2 shows an example of the output of the reduction function for a given formula in CNF.

We now show that every $\mathsf{SAT}$ instance $S$ is satisfiable if and only if $f(S)$ is a “yes” instance of k-ULGT. We start with the “only if” part for this is the simpler direction:

Lemma 2.3**.**

If a $\mathsf{SAT}$ instance $S$ as in Definition 2.2 is satisfiable then $f(S)=(G_{s},G_{t},k)$ with $k=2n+m$ is a k-ULGT instance and there is a computation with initial graph $G_{s}$ and final graph $G_{t}$ of length at most $2n+m$.

Proof 2.4**.**

Assume there is a satisfying truth assignment $t:X\rightarrow\{0,1\}$ of $S$. For every $1\leq i\leq n$ let $y_{i}:=x_{i}$ if $t(x_{i})=1$ or $y_{i}:=\overline{x_{i}}$ if $t(x_{i})=0$. We construct the following computation with initial graph $G_{s}$ and final graph $G_{t}$:

For every $1\leq i\leq n$, $s_{i}$ delegates the edge $\{s_{i},r\}$ to $y_{i}$. 2. 2.

For every $C_{j}\in\{C_{1},\dots,C_{m}\}$ choose one neighbor $z_{j}\in\{y_{1},\dots,y_{n}\}$ (we show below that this exists), and let $z_{j}$ introduce $r$ to $C_{j}$. 3. 3.

For every $1\leq i\leq n$, $y_{i}$ delegates the edge $\{y_{i},r\}$ to $t_{i}$.

Obviously, the length of this computation is $2n+m$. To prove the missing part, recall that every $C_{j}$ is satisfied under $t$, i.e., there is at least one literal $z_{j}$ in $C_{j}$ that evaluates to true, i.e., there is an $i\in[n]$ such that $z_{j}=x_{i}$ if $t(x_{i})=1$, or $z_{j}=\overline{x_{i}}$ if $t(x_{i})=0$. By definition of $y_{i}$, $z_{j}=y_{i}$. Thus because $z_{j}$ occurs in $C_{j}$, $y_{i}$ was a neighbor of $C_{j}$ during Step 2.

The “if” part is more complex. We begin with the following insight that will prove helpful in the course of this part.

Lemma 2.5**.**

Suppose the nodes in the initial graph of a computation $C$ can be decomposed into disjoint sets $V_{1},\dots,V_{k},P$ such that there is no edge $\{u,v\}$ for any $u\in V_{i}$, $v\in V_{j}$, $i,j\in[k]$, $i\neq j$ and throughout $C$ none of the nodes in $P$ applies a primitive. Then there is no edge $\{u,v\}$ for any $u\in V_{i}$, $v\in V_{j}$, $i,j\in[k]$, $i\neq j$ in any graph of the computation.

Proof 2.6**.**

Assume there is a computation $C$ and sets $V_{1},\dots,V_{k},P$ as defined above and assume for contradiction that the claim is not true. We consider the first edge $\{u,v\}$ such that $u\in V_{i}$, $v\in V_{j}$, $i,j\in[k]$, $i\neq j$. Clearly, it cannot have been created by the application of a fusion primitive. Thus it must have been created by an introduction or delegation primitive applied by a node $w$ that knew both $u$ and $v$ before the application of this primitive. This implies $w\in P$. However, the nodes in $P$ do not apply any primitives by assumption, which yields a contradiction.

In the rest of this section, we use the following notation: For a given instance of k-ULGT $(G_{s},G_{t},k)$, we say a computation is feasible if and only if its initial graph is $G_{s}$, its final graph is $G_{t}$ and its length is at most $2n+m$. Furthermore, we say that the edge that is established during the application of an introduction or delegation primitive (the edge $(v,w)$ in Figure 1(a) and Figure 1(b)) is the result of the introduction or delegation, respectively.

The next lemma we show represents a main building block of the proof of the “if” part.

Lemma 2.7**.**

Let $S$ be a $\mathsf{SAT}$ instance and let $(G_{s},G_{t},k)=f(S)$. For every computation $C$ with initial graph $G_{s}$ and final graph $G_{t}$ of length at most $2n+m$ it holds: There are $y_{1},\dots,y_{n}$, $y_{i}\in\{x_{i},\overline{x_{i}}\}$ for every $i\in[n]$, such that in $C$ there are no edges other than $E(G_{s})\cup E(G_{t})\cup\{\{y_{i},r\}|i\in[n]\}$ and no edge occurs twice in any graph of $C$ (where $E(G_{s})$ and $E(G_{t})$ denote the edge sets of $G_{s}$ and $G_{t}$, respectively).

The general idea of the proof of Lemma 2.7 is the following: To obtain the final graph, for each $j\in[m]$ the edge $\{C_{j},r\}$ has to be created and for each $i\in[n]$ the edge $\{t_{i},r\}$ has to be created. Each of these creations involves a distinct application of a primitive. Therefore, only $n$ applications of primitives are left in a feasible computation. We show that the nodes in each gadget $i$ have to apply at least one primitive $p_{i}$ that does not create one of the above edges. This implies that each gadget may apply no other primitive than $p_{i}$ to create an edge that is not in the final graph and that the nodes $r$ and $C_{j}$ themselves cannot apply any primitives at all which by Lemma 2.5 means that there are no inter-gadget edges. We use these facts to prove that $p_{i}$ is used to remove the edge $\{s_{i},r\}$ thereby creating either $\{x_{i},r\}$ or $\{\overline{x_{i}},r\}$.

We split the full proof of Lemma 2.7 into three claims, which we prove individually. The first claim we show is the following:

Claim 1**.**

In every feasible computation for every $i\in[n]$, there is a node $z_{i}\in\{s_{i},x_{i},\overline{x_{i}}\}$ that applies a fusion primitive or an introduction or delegation primitive whose result is not in $E_{c}:=\{\{C_{j},r\}|1\leq j\leq m\}\cup\{\{t_{i},r\}|1\leq i\leq n\}\cup\{\{C_{j},C_{l}\}|i,j\in[m]\}\cup\{\{t_{i},C_{j}\}|i\in[n],j\in[m]\}\cup\{\{t_{i},t_{k}\}|i,k\in[n]\}$.

Proof 2.8**.**

Assume for contradiction that there is a feasible computation and an $i\in[n]$ such that there is no $z_{i}\in\{s_{i},x_{i},\overline{x_{i}}\}$ that applies a fusion primitive or an introduction or delegation primitive whose result is not in $E_{c}$. Note that $s_{i}$ cannot delegate away any of its incident edges $\{s_{i},x_{i}\}$ or $\{s_{i},\overline{x_{i}}\}$ as the result would not be in $E_{c}$ (for it would be incident to $x_{i}$ or $\overline{x_{i}}$). Similarly, $x_{i}$ and $\overline{x_{i}}$ could not delegate away $\{x_{i},s_{i}\}$ and $\{\overline{x_{i}},s_{i}\}$, respectively. Therefore, the edges $\{x_{i},s_{i}\}$ and $\{s_{i},\overline{x_{i}}\}$ must be kept throughout the computation. Now observe that $s_{i}$ has an initial degree of three. Since $s_{i}$ has a degree of two in the final graph, there must be at least one application of a primitive in which $s_{i}$’s degree decreases. Consider the last such application, i.e., the resulting neighborhood of $s_{i}$ is $x_{i}$ and $\overline{x_{i}}$ (remember that these edges persist throughout the computation). If it was an application of a fusion primitive, then $x_{i}$, $s_{i}$ or $\overline{x_{i}}$ must have applied this primitive, yielding a contradiction. Otherwise, it must have been a delegation primitive applied by $s_{i}$ for no other primitive could reduce $s_{i}$’s degree then. However, the result of this delegation primitive must be an edge incident to $x_{i}$ or $\overline{x_{i}}$ then, i.e., an edge not in $E_{c}$ yielding a contradiction in this case as well. All in all, we have proven 1.

The second claim we prove is:

Claim 2**.**

For every feasible computation $C$, the following holds:

1. (i)

for each $i\in[n]$ the nodes in $V_{X_{i}}$ may apply at most one primitive whose result is not an edge $\{t_{k},r\}$ or $\{C_{j},r\}$ for $k\in[n],j\in[m]$, 2. (ii)

the nodes in $\{r\}\cup\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$ do not apply any primitives at all, and 3. (iii)

there is no graph in $C$ that contains an edge $\{u,v\}$ such that $u\in V_{X_{i}}$ and $v\in V_{X_{k}}$ for any $i,k\in[n]$ such that $i\neq k$.

Proof 2.9**.**

For the proof of this claim we distinguish between three types of edges. Edges $\{t_{i},r\}$ for some $i\in[n]$ belong to type A. Edges $\{C_{j},r\}$ for some $j\in[m]$ belong to type B. Last every edge $e\notin E_{c}$ belongs to type $C$. Note that in order to obtain the final graph, the nodes need to establish $n$ edges of type A, $m$ edges of type B, and, according to 1, for every $i\in[n]$, one of the nodes in $\{s_{i},x_{i},\overline{x_{i}}\}$ has to apply a primitive whose result is an edge of type C or which is a fusion primitive. Since there may be at most $2n+m$ applications of primitives, no other primitives may be applied. This immediately proves (i). Since $r$ cannot create the first instance of an edge of type A or B by itself, $r$ cannot apply any primitive at all as this would require more than $2n+m$ primitive applications then ($n+m$ are used to create the type A/B edges and an additional $m$ primitives are applied by the nodes from $\{s_{i},x_{i},\overline{x_{i}}|i\in[n]\}$). For the same reason, the nodes in $\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$ cannot apply any primitives, which together with the fact that $r$ cannot apply any primitives equates to (ii). In addition this implies that the initial graph can be decomposed into $V_{X_{1}},V_{X_{2}},\dots,V_{X_{n}},P$ with $P=\{r\}\cup\{C_{j}|j\in[m]\}$ such that there is no edge $\{u,v\}$ for any $u\in V_{X_{i}},v\in V_{X_{k}}$, $i,k\in[n]$ and $i\neq k$, and the nodes in $P$ do not apply any primitive at all. Thus, (iii) follows from Lemma 2.5.

The last claim we show is the following:

Claim 3**.**

In every feasible computation, for every $i\in[n]$ there must be a graph containing an edge $\{x_{i},r\}$ or $\{\overline{x_{i}},r\}$.

Proof 2.10**.**

To prove 3, we show that $s_{i}$ has to delegate $\{s_{i},r\}$ to $x_{i}$ or $\overline{x_{i}}$. We do so by proving that $s_{i}$ cannot have a neighbor other than $x_{i}$, $\overline{x_{i}}$ or $r$, which is sufficient because $r$ does not apply any primitive according to (ii) of 2. Assume for contradiction that $s_{i}$ has an edge $\{s_{i},v\}$ such that $v\notin\{x_{i},\overline{x_{i}},r\}$ and let $\{s_{i},v\}$ be the last such edge that occurs in a graph in the computation. Due to (iii) of 2, $v\in\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$. Consider the node $w$ that applied an introduction or delegation primitive whose result was the edge $\{s_{i},v\}$. For this to be possible, there must have been an edge $\{w,s_{i}\}$ when $w$ applied the primitive. Since $r$, all $t_{i}$ for $i\in[n]$, and all $C_{j}$ for $j\in[m]$ do not apply any primitives according to (ii) of 2 and because of (iii) of 2, $w\in\{x_{i},s_{i},\overline{x_{i}}\}$. According to (i) of 2, the computation may not contain another application (than this one) of a delegation / introduction primitive by a node in $V_{X_{i}}$ whose result is not an edge $\{t_{k},r\}$ or $\{C_{j},r\}$ for $k\in[n],j\in[m]$ (). Since $\{s_{i},v\}\notin E(G_{t})$, this edge must be removed by some application of a delegation primitive. Note that since $v\in\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$, $s_{i}$ must apply this primitive. Since $\{s_{i},v\}$ is the last edge different from $\{s_{i},r\}$, $\{s_{i},x_{i}\}$, and $\{s_{i},\overline{x_{i}}\}$, $v$ must be delegated to one of the nodes $r$, $x_{i}$, and $\overline{x_{i}}$. If $s_{i}$ delegates $\{s_{i},v\}$ to $x_{i}$ or $\overline{x_{i}}$, then the result is an edge $\{x_{i},v\}$ or $\{\overline{x_{i}},v\}$, which contradicts (). Thus assume $s_{i}$ delegates $\{s_{i},v\}$ to $r$. Note that after this delegation, the edge $\{s_{i},r\}$ exists and $s_{i}$ does not have a neighbor $v^{\prime}\in\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$ in any of the subsequent graphs (recall that $v$ was the last edge of its kind). Since $\{s_{i},r\}\notin E(G_{t})$, and $r$ does not apply any primitives according to (ii) of 2, this edge must be delegated to either $x_{i}$ or $\overline{x_{i}}$ yielding an edge $\{x_{i},r\}$ or $\{\overline{x_{i}},r\}$, which contradicts () as well. As mentioned above this proves that $s_{i}$ has to delegate $\{s_{i},r\}$ to $x_{i}$ or $\overline{x_{i}}$, and, as argued before as well, also implies the claim of the lemma.*

3 gives that during a feasible computation, the edges $\{t_{i},r\}$ for all $i\in[n]$, $\{C_{j},r\}$ for all $j\in[m]$ and $\{y_{i},r\}$, $y_{i}\in\{x_{i},\overline{x_{i}}\}$ for all $i\in[n]$ have to be created. Since each primitive can create at most one of these edges and the length of the computation is at most $2n+m$, this implies the claim of Lemma 2.7.

The rest of the proof of the “if” part, as formalized by the following lemma, is comparably straightforward.

Lemma 2.11**.**

Let $S$ be a $\mathsf{SAT}$ instance as in Definition 2.2. If $f(S)=(G_{s},G_{t},k)$ with $k=2n+m$ is a k-ULGT instance and there is a computation with initial graph $G_{s}$ and final graph $G_{t}$ of length at most $2n+m$, then $S$ is satisfiable.

Proof 2.12**.**

Assume that $f(S)=(G_{s},G_{t},2n+m)$ is a k-ULGT instance and there is a feasible computation $C$ for $f(S)$. According to Lemma 2.7 there are $y_{1},\dots,y_{n}$, $y_{i}\in\{x_{i},\overline{x_{i}}\}$ for every $i\in[n]$ such that in $C$ there are no edges other than $E(G_{s})\cup E(G_{t})\cup\{\{y_{i},r\}|i\in[n]\}$. Note that in $G_{t}$, for every $j\in[m]$ there is an edge $\{C_{j},r\}$ and each such edge must have been the result of an introduction or delegation primitive applied by an $y_{i}$, $i\in[n]$ (as throughout $C$, the $C_{j}$ nodes do not have any other neighbors with an edge to $r$ that could possibly create this edge) . Let $g:\{C_{1},C_{2},\dots,C_{m}\}\rightarrow\{y_{1},y_{2},\dots,y_{n}\}$ be the mapping of each $C_{j}$ to the $y_{i}$ that applied a primitive that resulted in the edge $\{C_{j},r\}$. Consider the truth assignment $t:X\rightarrow\{0,1\}$ such that $t(x_{i})=1$ if $y_{i}=x_{i}$ and $t(x_{i})=0$ if $y_{i}=\overline{x_{i}}$. Observe that $t(y_{i})=1$ for every $i\in[n]$. Assume for contradiction that there is a clause $C_{j}$ in $S$ that does not evaluate to true under $t$. Note that $g(C_{j})$ must occur in $C_{j}$ by construction. However, since $g(C_{j})=y_{i}$ for some $i\in[n]$ and $t(y_{i})=1$, we obtain the desired contradiction.

Putting both parts together, Lemma 2.3 and Lemma 2.11 imply $\mathsf{SAT}\leq_{p}\textsc{k-ULGT}$, from which we obtain:

Corollary 2.13**.**

k-ULGT* is $\mathsf{NP}$-hard.*

2.2 k-DLGT is $\mathsf{NP}$-hard

The proof of the $\mathsf{NP}$-hardness of k-DLGT is very similar to that of k-ULGT. Therefore, we do not restate the whole proof but point out the differences between the two proofs.

The reduction function is a “directed version” of Definition 2.2, in which each of the edges is assigned as unique direction. Formally, it looks as follows:

Definition 2.14** (Reduction function for $SAT\leq_{p}\textsc{k-DLGT}$).**

Let $S=(X,\Phi)$ be a $\mathsf{SAT}$ instance, in which $X=\{x_{1},\dots,x_{n}\}$ is the set of Boolean variables and $\Phi=C_{1}\land\dots\land C_{m}$ for clauses $C_{1},\dots,C_{m}$. Then $f(S)=(G_{s},G_{t},k)$ in which $k=2n+m$ and $G_{s}$ and $G_{t}$ are undirected graphs defined as follows. Without loss of generality, assume that each literal $y_{i}\in\{x_{i},\overline{x_{i}}\}$ occurs only once in each clause.

We define the following sets of nodes: $V_{C}=\{C_{1},\dots,C_{m}\}$, and $V_{X_{i}}=\{x_{i},\overline{x_{i}},s_{i},t_{i}\}$. Then, the set of nodes of $G_{s}$ and $G_{t}$ is $V=\bigcup_{1\leq i\leq n}V_{X_{i}}\cup V_{C}\cup\{r\}$. For the set of edges, define $E_{X_{i}}=\{(s_{i},x_{i}),(s_{i},\overline{x_{i}}),(x_{i},t_{i}),(\overline{x_{i}}),t_{i}\}$ for every $i\in[n]$, $E_{C_{j}}=\{(y_{i},C_{j})|y_{i}\in\{x_{i},\overline{x_{i}}\}\land y_{i}\text{ occurs in }C_{j}\}$ for every $j\in[m]$, $E_{sr}=\{(s_{i},r)|1\leq i\leq n\}$, $E_{tr}=\{(t_{i},r)|1\leq i\leq n\}$, $E_{Cr}=\{(C_{j},r)|1\leq j\leq m\}$. Both $G_{s}$ and $G_{t}$ have the edges in $\bigcup_{1\leq i\leq n}E_{X_{i}}\cup\bigcup_{1\leq j\leq m}E_{C_{j}}$. Additionally, $G_{s}$ has the edges in $E_{sr}$ and $G_{t}$ has the edges in $E_{tr}\cup E_{Cr}$.

An example of the output of this reduction function is depicted in Figure 3. Note that this picture only differs from Figure 2 in that the edges are directed. More specifically, all solid edges are directed “downwards”, the dashed edges are directed “upwards” and all grey nodes are supposed to have an an “upward” edge to $r$ in $G_{t}$.

We now point out the differences in the proofs for the directed case, in which we refer to the lemmas from Section 2.1. Note that to shorten the description, every edge $\{u,v\}$ that appears in the proof for the undirected case should be read as the directed edge $(u,v)$ unless noted differently.

Lemma 2.3 (the “only if” part of the reduction) directly transfers to the directed case: the same approach described in that proof can be applied in the k-DLGT scenario as well.

For the directed version of Lemma 2.5, the same proof applies where the only additional argument to be mentioned is that the first edge $(u,v)$ such that $u\in V_{i},v\in V_{j},i,j\in[k],i\neq j$ not only cannot have been created by the application of a fusion primitive, but also not by the application of a reversal primitive.

For the proof of the counterpart of Lemma 2.7, we consider all three claims used for that lemma individually. The argument showing that the claim of the lemma follows from these three claims is analogous.

1 must be completed such that $z$ applied either a fusion primitive or an introduction, delegation or reversal primitive whose result is not in $E_{c}$. This set of edges is defined as: $E_{c}:=\{(C_{j},r)|1\leq j\leq m\}\cup\{(r,C_{j})|1\leq j\leq m\}\cup\{(t_{i},r)1\leq i\leq n\}\cup\{(r,t_{i})1\leq i\leq n\}\cup\{(C_{j},C_{l})i,j\in[m]\}\cup\{(t_{i},C_{j})i\in[n],j\in[m]\}\cup\{(C_{j},t_{i})i\in[n],j\in[m]\}\cup\{(t_{i},t_{k})i,k\in[n]\}$. In the proof, the assumption for contradiction includes that none of the $z_{i}$ applies a reversal primitive whose result is not in $E_{c}$. In addition to that $s_{i}$ cannot delegate away $(s_{i},x_{i})$ and $(s_{i},\overline{x_{i}})$, we argue that $s_{i}$ cannot reverse this edge as the result would not be in $E_{c}$. These two facts immediately imply that $(s_{i},x_{i})$ and $(s_{i},\overline{x_{i}})$ persist throughout the computation. For the last primitive application that reduces $s_{i}$’s degree to two, we have to take into account that this could also be the application of a reversal primitive. However, in that case, the result of this primitive application would be an edge whose one endpoint is $s_{i}$, i.e., an edge not in $E_{c}$, yielding a contradiction as well.

In the proof of 2 we need the following additional argument to show that $r$ cannot apply any primitives (the previous argument that $r$ cannot create the first instance of an edge of type A or B by itself does not suffice if the reversal primitive could also be applied): Since no primitives other than the $n$ creating the type A edges, the $m$ creating the type $B$ edges and the $n$ creating the type $C$ edges or being a fusion primitive can be applied, there cannot be any edge $E_{c}\setminus\{(t_{i},r),(C_{j},r)|i\in[n],j\in[m]\}$ in any graph of the computation. In particular, there can be no edge $(r,C_{j})$ for any $j\in[m]$ or $(r,t_{i})$ for any $i\in[n]$. Thus, $r$ cannot create the first instance of a type A or B edge via a reversal primitive and together with the previous argument we also obtain that $r$ cannot apply any primitive at all.

In the proof of 3, in order to show that $s_{i}$ has to delegate $(s_{i},r)$ to $x_{i}$ or $\overline{x_{i}}$, we similarly show prove that $s_{i}$ cannot have an outgoing neighbor other than $x_{i}$, $\overline{x_{i}}$, or $r$. In the directed scenario, however, this is not immediately sufficient because $r$ does not apply any primitive. Additionally, we have to consider that $s_{i}$ cannot simply reverse edge $(s_{i},r)$ as the resulting edge does not belong to $G_{t}$ and $r$ does not apply any primitive, which would be necessary to remove that edge again. After that, note that the edge $(s_{i},v)$ such that $v\notin\{x_{i},\overline{x_{i}},r\}$ which we assume to exist for contradiction cannot have been established by the application of a reversal primitive, for such a $v$ cannot apply any primitive at all according to Item ii (since $v\in\{t_{i}|i\in[n]\}\cup\{C_{j}|j\in[m]\}$ follows equally in the directed case). Thus it is feasible to continue with the consideration of the $w$ that applied an introduction or delegation primitive whose result was $(s_{i},v)$. The claim (*) in the directed case is that the computation may not contain another application (than the one applied by $w$ to create $(s_{i},v)$) of a delegation, introduction, or reversal primitive by a node in $V_{X_{i}}$ whose result is not an edge $(t_{k},r)$ or $(C_{j},r)$ for $k\in[n],j\in[m]$. Again, in order to remove $(s_{i},v)\notin E(G_{t})$, $s_{i}$ must apply a delegation primitive to remove this edge. In this case, the argument is that $s_{i}$ cannot reverse the edge because $(v,s_{i})\notin E(G_{t})$ and $v$ does not apply any primitive (as argued before). In the last contradiction of the proof, which relies on that $(s_{i},r)\notin E(G_{t})$, there is not only the option that $s_{i}$ delegates this edge to $x_{i}$ or $\overline{x_{i}}$, but also that $s_{i}$ reverses this edge. This however would yield an edge $(r,s_{i})$, which does not belong to $G_{t}$ and could not be removed, for $r$ does not apply any primitives.

The last lemma required is Lemma 2.11, but this is completely analogous. All in all, we obtain as for the undirected case:

Corollary 2.15**.**

k-DLGT* is $\mathsf{NP}$-hard.*

3 Approximation Algorithms

The main part of this section consists in describing and analyzing a constant approximation algorithm for ULGT (Section 3.1). As it turns out, an algorithm for DLGT can be obtained by a suitable adaptation of this algorithm, as we will elaborate on in Section 3.2.

As an ingredient our algorithms use a 2-approximation algorithm for the following problem:

Definition 3.1** (Undirected Steiner Forest Problem (USF)).**

The Undirected Steiner Forest Problem (USF) is defined as follows: For a given input $(G,S)$ such that $G$ is a graph and $S$ is a set of pairs of nodes from $G$, find a forest $F$ in $G$ with a minimum number of edges such that the two nodes of each pair in $S$ are connected by a path in $F$.

As described in Section 1.2, such an approximation algorithm already exists. We will use it as a black box and thus not discuss it any further.

3.1 A Constant Approximation Algorithm for ULGT

We now describe an approximation algorithm for ULGT (Section 3.1.1) and prove it to have a constant approximation ratio (Section 3.1.2).

3.1.1 Algorithm Description

For an initial graph $G_{s}=(V,E_{s})$ and a final graph $G_{t}=(V,E_{t})$, we define the set of additional edges $E_{\oplus}:=E_{t}\setminus E_{s}$ and the set of excess edges $E_{\ominus}:=E_{s}\setminus E_{t}$. We now describe the algorithm in detail and then summarize its pseudo-code in Algorithm 1. Our algorithm consists of two parts, the first of which deals with establishing all additional edges and the second of which deals with removing all excess edges. In the first part, using an arbitrary 2-approximation algorithm for the USF as a black box, the algorithm computes a 2-approximate solution to the following USF instance: The given graph is $G_{s}$, and the set of pairs of nodes is $E_{\oplus}$. Note that the result is a forest such that for every edge $\{u,v\}\in E_{\oplus}$, $u$ and $v$ belong to the same tree. For each tree $T$ in this forest the algorithm then selects an arbitrary root $r_{T}$ and connects all nodes in $T$ that are incident to an edge in $E_{\oplus}$ to $r_{T}$. The exact details of this will be described when we analyze the length of the resulting computation. In the next step, for every tree $T$, and every $\{u,v\}\in E_{\oplus}$ such that $u$ and $v$ belong to $T$, $r_{T}$ introduces $u$ and $v$ to each other, thereby creating the edge $\{u,v\}$. After that, the superfluous edges (i.e., those edges that belong neither to $G_{s}$ nor to $E_{\oplus}$) are deleted in a bottom-up fashion: every node that does not have a descendant with a superfluous edge (in the tree $T$ this node belongs to when viewing this tree as rooted by $r_{T}$), fuses all superfluous edges and delegates the last such to its parent in the tree. Note that all superfluous edges in the same tree $T$ have $r_{T}$ as one of their endpoints. The second part of the algorithm is similar to the first, with the following differences: In the fifth step, the USF is approximated for the input $(G_{t},E_{\ominus})$. Note that the solution is a subgraph of the graph obtained after the first part of the algorithm. In the sixth step, only one of the two endpoints of an edge from $E_{\ominus}$ is selected to become connected with the root of the tree the endpoints belong to. In the seventh step (where in the first part the additional edges are created by the $r_{T}$ nodes), for each edge $e\in E_{\ominus}$, the endpoint selected in the sixth step delegates this edge to $r_{T}$ (resulting in the edge $\{r_{T},v\}$). These edges can then be delegated and fused in a bottom-up fashion by the endpoints other than $r_{T}$ in Step 8. In contrast to Step 4, we begin with applying fusions here because the edges superfluous $\{r_{T},v\}$ exist twice here (one was created in Step 6, and one in Step 7).

3.1.2 Analysis

In this section we show that Algorithm 1 is a constant-approximation algorithm for ULGT, which proves the following theorem:

Theorem 3.2**.**

$\textsc{ULGT}\in\mathsf{APX}$.

For convenience we will analyze the two parts of the algorithm individually. Therefore, for a given initial graph $G_{s}$ and final graph $G_{t}$, let $ALG_{1}(G_{s},G_{t})$ be the length of the computation of the first part of the algorithm for this instance, $ALG_{2}(G_{s},G_{t})$ be the length of the computation of the second part, and $ALG(G_{s},G_{t}):=ALG_{1}(G_{s},G_{t})+ALG_{2}(G_{s},G_{t})$. Furthermore, let $OPT(G_{s},G_{t})$ be the length of an optimal solution to ULGT for initial graph $G_{s}$ and final graph $G_{t}$. We also define the intermediate graph $G^{\prime}=(V,E_{s}\cup E_{\oplus})$. In the course of the analysis we will establish a relationship between $ALG_{1}(G_{s},G_{t})$ and $OPT(G_{s},G^{\prime})$ and between $ALG_{2}(G_{s},G_{t})$ and $OPT(G^{\prime},G_{t})$. This will aid us in determining the approximation factor of Algorithm 1 due to the following lemma:

Lemma 3.3**.**

$OPT(G_{s},G^{\prime})+OPT(G^{\prime},G_{t})\leq 2OPT(G_{s},G_{t})+|E_{\oplus}|$.

Proof 3.4**.**

Let $\mathcal{P}$ denote the problem equal to ULGT with initial graph $G_{s}$ and final graph $G_{t}$ with the additional requirement that the computation must contain $G^{\prime}$ and let $OPT^{\prime}(G_{s},G^{\prime},G_{t})$ be the length of an optimal solution to it. Clearly, $OPT(G_{s},G^{\prime})+OPT(G^{\prime},G_{t})=OPT^{\prime}(G_{s},G^{\prime},G_{t})$ (note that one could split the optimal solution to $P$ at $G^{\prime}$). We now show that $OPT^{\prime}(G_{s},G^{\prime},G_{t})\leq 2OPT(G_{s},G_{t})+|E_{\oplus}|$.

Consider a computation $C$ whose initial graph is $G_{s}$, whose final graph is $G_{t}$ and whose length is $OPT(G_{s},G_{t})$ (note that such a computation is an optimal solution to ULGT). We now transform $C$ into a computation that represents a solution to $\mathcal{P}$. This transformation increases its length by only $OPT(G_{s},G_{t})+|E_{\oplus}|$ and thus proves the above claim.

Note that every edge $\{u,v\}\in E_{\ominus}$ is removed during $C$. This may happen due to the application of a fusion primitive (in case $G_{t}$ contains another edge; recall that edges may have a multiplicity of more than one) or a delegation primitive. For all edges to which the former case applies, we simply omit that application of a fusion primitive. For all edges to which the latter case applies, we replace each of these applications of delegation primitives by applications of introduction primitives. Altogether, we obtain a new computation $C^{\prime}$ of equal length. Note that changing these primitive applications does not make the computation infeasible as this only causes the graph to have additional edges. The final graph of $C^{\prime}$ is $(V,E_{t}\cup E_{\ominus})=(V,E_{s}\cup E_{\oplus})=G^{\prime}$ (recall that $E_{t}=(E_{s}\cup E_{\oplus})\setminus E_{\ominus}$). Next we append $C^{\prime}$ by $C$ and obtain the computation $C^{\prime\prime}$ of length $2OPT(G_{s},G_{t})$. Note that since $C$ transformed $G_{s}$ to $G_{t}$, this second half of $C^{\prime\prime}$, which starts from $G^{\prime}=(V,E_{s}\cup E_{\oplus})$, has the final graph $G^{\prime\prime}=(V,E_{t}\cup E_{\oplus})$, i.e., each edge from $E_{\oplus}$ appears twice in $G^{\prime\prime}$. Thus we extend $C^{\prime\prime}$ by fusing each edge from $E_{\oplus}$ with its double, resulting in a computation $C^{\prime\prime\prime}$ of length $2OPT(G_{s},G_{t})+|E_{\oplus}|$. Since $C^{\prime\prime\prime}$ represents a solution to $\mathcal{P}$ for initial graph $G_{s}$ and final graph $G_{t}$, this completes the proof.

One might question whether this bound is tight or if it is possible to, e.g., get rid of the additional $|E_{\oplus}|$ addend by a more careful analysis. Figure 4 shows that this bound is indeed tight and shows an example where $OPT(G_{s},G^{\prime})+OPT(G^{\prime},G_{t})=2OPT(G_{s},G_{t})+|E_{\oplus}|$.

In the rest of the analysis we show that $ALG_{1}(G_{s},G_{t})\leq 11OPT(G_{s},G^{\prime})$ (Lemma 3.5) and that $ALG_{2}(G_{s},G_{t})\leq 11OPT(G^{\prime},G_{t})$ (Lemma 3.7). By Lemma 3.3 this implies that $ALG(G_{s},G_{t})\leq 11(2OPT(G_{s},G_{t})+|E_{\oplus}|)\leq 33OPT(G_{s},G_{t})$ (since, clearly, $OPT(G_{s},G_{t})\geq|E_{\oplus}|$), which yields the claim of Theorem 3.2. We start with the former claim:

Lemma 3.5**.**

$ALG_{1}(G_{s},G_{t})\leq 11OPT(G_{s},G^{\prime})$.

Proof 3.6**.**

Let $F_{OPT,\oplus}$ be an optimal solution to the USF with input $(G_{s},E_{\oplus})$ and recall that $F_{ALG,\oplus}$ is the USF approximation computed in Step 1 of Algorithm 1. Throughout the analysis, $|F_{OPT,\oplus}|$ and $|F_{ALG,\oplus}|$ will denote the number of edges in these solutions. In the first part of this proof, we show that $ALG_{1}(G_{s},G_{t})\leq 4|F_{OPT,\oplus}|+3|E_{\oplus}|$. The second part then consists in proving $OPT(G_{s},G^{\prime})\geq|F_{OPT,\oplus}|-|E_{\oplus}|$, which together with the observation that $OPT(G_{s},G^{\prime})\geq|E_{\oplus}|$ yields the claim.

To upper bound $ALG_{1}(G_{s},G_{t})$, we analyze the number of primitives applied in each of the steps of the first part of the approximation algorithm. In Step 1, no primitive is applied. To keep the number of edges as low as possible (which saves fusion primitives in Step 4), the algorithm for every $T$ in $F_{ALG,\oplus}$ connects the desired nodes to $r_{T}$ in Step 2 in the following way: To simplify the description, we view $T$ as rooted at $r_{T}$ and for a node $u\in T$ denote by $ST(u)$ the set consisting of $u$ and all of its descendants in the tree $T$ rooted at $r_{T}$. We say a node $u$ is relevant if $ST(u)$ contains a node with an endpoint in $E_{\oplus}$111Note that although any tree in $F_{ALG,\oplus}$ that contains nodes that are not relevant for any root could trivially be reduced in size, we have to take into account that such trees exist since we treat the approximation algorithm for USF as a black box.. See Figure 5 for an illustration of these notions. First of all, $r_{T}$ introduces itself to all relevant children. Then, starting from the second level, we proceed level-wise in the tree: For each level $i$, every node $u$ at level $i$ checks whether $u$ is an endpoint of an edge in $E_{\oplus}$. If so, $u$ introduces $r_{T}$ to all relevant children. Otherwise, $u$ introduces $r_{T}$ to all but one of its relevant children (chosen arbitrarily) and delegates $r_{T}$ to the relevant child it did not introduce $r_{T}$ to. The result of this procedure is that each node incident to an edge in $E_{\oplus}$ has an edge to $r_{T}$ for the tree $T$ it belongs to, see Figure 5(a). Note that according to the definition of $F_{ALG,\oplus}$, for each pair $\{u,v\}\in E_{\oplus}$ $u$ and $v$ belong to the same tree $T$. The above procedure increases the number of edges by at most $2|E_{\oplus}|$ and requires at most $|F_{ALG,\oplus}|$ applications of primitives (at most one for every edge in $T$). It is easy to see that Step 3 (c.f. Figure 5(b)) involves exactly $E_{\oplus}$ applications of primitives. For the length of Step 4 (c.f. Figure 5(c)), note that for every tree $T$ at most one delegation has to be applied for every edge in $T$ (causing $|F_{ALG,\oplus}|$ delegations in total) and at most $2|E_{\oplus}|$ fusions have to be applied for this is the number of superfluous edges created during Step 2. All in all, Step 2, Step 3, and Step 4 involve $|F_{ALG,\oplus}|$, $|E_{\oplus}|$, and $|F_{ALG,\oplus}|+2|E_{\oplus}|$ applications of primitives, respectively. This makes a total of $2|F_{ALG,\oplus}|+3|E_{\oplus}|$. Since $F_{ALG,\oplus}$ is a 2-approximation of $F_{OPT,\oplus}$, we obtain $ALG_{1}(G_{s},G_{t})\leq 4|F_{OPT,\oplus}|+3|E_{\oplus}|$.

For the lower bound on $OPT(G_{s},G^{\prime})$, assume for contradiction that there is a computation $C$ with initial graph $G_{s}$ and final graph $G^{\prime}$ of length $L<|F_{OPT,\oplus}|-|E_{\oplus}|$. Let $G_{s}=G_{1}\Rightarrow G_{2}\Rightarrow\dots\Rightarrow G_{L}$ be the sequence of graphs of this computation. For every $\{u,v\}\in E_{\oplus}$ we iteratively create a path from $u$ to $v$ in the following way: Begin with $P_{u,v}^{L}:=(u,v)$. Note that $P_{u,v}^{L}$ exists in $G_{L}$. We iterate through $C$ in reverse order and for every graph $G_{i}$, if $P_{u,v}^{i+1}$ exists in $G_{i}$, $P_{u,v}^{i}:=P_{u,v}^{i+1}$. Otherwise, since $G_{i+1}$ is the result of a single application of a primitive to $G_{i}$, there is exactly one edge $\{x,y\}$ in $P_{u,v}^{i+1}$ that exists in $G_{i+1}$ but not in $G_{i}$ and this edge was created by the application of an introduction or delegation primitive of some node $w$ such that $\{w,x\}$ and $\{w,y\}$ exist in $G_{i}$. Thus, let $P_{u,v}^{i}$ be $P_{u,v}^{i+1}$ with $(x,y)$ replaced by $(x,w,y)$ and note that $P_{u,v}^{i}$ exists in $G_{i}$. Eventually, we obtain a path $P_{u,v}^{1}$ that exists in $G_{s}$. For $i\in\{1,\dots,L\}$, let $F^{i}:=\bigcup_{\{u,v\}\in E_{\oplus}}E(P_{u,v}^{i})$ (where $E(P)$ is the set of all edges on the path $P$) be a normal set of edges (i.e., not a multiset). Note that $F^{1}$ can be transformed into a feasible (though not necessarily optimal) solution to the USF with input $(G_{s},E_{\oplus})$ by removing cycle edges. Therefore, $|F^{1}|\geq|F_{OPT,\oplus}|$. An example is given in Figure 6.

For an arbitrary $i\in\{1,\dots,L-1\}$, note that $|F^{i}|\leq|F^{i+1}|+1$: if $G_{i+1}$ was obtained from $G_{i}$ by the application of a fusion primitive, this inequality trivially holds as none of the above paths changes in this case. Otherwise, $G_{i+1}$ was obtained from $G_{i}$ by an application of an introduction or delegation primitive by some node $w$ causing at most one edge $\{x,y\}$ to exist in $G_{i+1}$ that does not exist in $G_{i}$. In this case, we further know that $\{w,x\}$ and $\{w,y\}$ exist in $G_{i}$ and by the definition of the above paths, for every pair $\{u,v\}$ such that $P_{u,v}^{i+1}$ contains the edge $\{x,y\}$ the path $P_{u,v}^{i}$ contains $(x,w,y)$ as a sub-path instead and for all other pairs $\{u^{\prime},v^{\prime}\}$, $P_{u^{\prime},v^{\prime}}^{i}=P_{u^{\prime},v^{\prime}}^{i+1}$. By the definition of $F^{i}$ and $F^{i+1}$, this implies $|F^{i}|\leq|F^{i+1}|+1$ also in this case. All in all we obtain that $|F^{1}|\leq|F^{L}|+L=|E_{\oplus}|+L$ because $F^{L}=E_{\oplus}$ (note the definition of $F^{L}$). By the assumption that $L<|F_{OPT,\oplus}|-|E_{\oplus}|$, we obtain $|F^{1}|<|F_{OPT,\oplus}|$, which represents a contradiction.

Lemma 3.7**.**

$ALG_{2}(G_{s},G_{t})\leq 11OPT(G^{\prime},G_{t})$.

Proof 3.8**.**

The general structure of this proof follows the line of the proof of Lemma 3.5, but differs in the details. Similar to the notation used in that proof, let $F_{OPT,\ominus}$ be an optimal solution for the USF with input $(G_{t},E_{\ominus})$ and recall that $F_{ALG,\ominus}$ is the USF approximation computed in Step 5 of Algorithm 1. Analogously, $|F_{OPT,\ominus}|$ and $|F_{ALG,\ominus}|$ denote the number of edges in these solutions. In the first part of this proof, we show that $ALG_{2}(G_{s},G_{t})\leq 4|F_{OPT,\ominus}|+3|E_{\ominus}|$. The second part then consists in proving $OPT(G^{\prime},G_{t})\geq|F_{OPT,\ominus}|-|E_{\ominus}|$, which together with the observation that $OPT(G^{\prime},G_{t})\geq|E_{\ominus}|$ yields the claim.

To upper bound $ALG_{2}(G_{s},G_{t})$, we analyze the number of primitives applied in each step of the second part of the approximation algorithm. Of course, no primitive is applied in Step 5. The connections required in Step 6 can be created in a similar fashion as in Step 2, which is described in the proof of Lemma 3.5: For each tree $T$, we proceed top-down in $T$ rooted at some arbitrary but fixed node $r_{T}$ again. Here, each intermediate node $u$ checks whether $u=s(e)$ for some $e\in E_{\ominus}$. If so, it introduces $r_{T}$ to all relevant children (here a node $v$ is relevant if $ST(v)$ contains a node $w$ such that $w=s(e^{\prime})$ for some $e^{\prime}\in E_{\ominus}$). Otherwise, it introduces $r_{T}$ to all but one relevant children and delegates it to the remaining one. In the end, for every edge $e\in E_{\ominus}$, $s(e)$ has an edge to $r_{T}$, the number of edges in the graph has increased by at most $|E_{\ominus}|$, and the process involved at most $|F_{ALG,\ominus}|$ applications of primitives. In Step 7, clearly exactly $|E_{\ominus}|$ edges have to be delegated. Step 8 is similar to Step 4 and for analogous reasons requires at most $|F_{ALG,\ominus}|$ delegations and at most $2|E_{\ominus}|$ fusions (recall that up to $|E_{\ominus}|$ edges were added in Step 6 and the edges delegated in Step 7 have to be removed as well). All in all, Step 6, Step 7 and Step 8 of the algorithm involve at most $|F_{ALG,\ominus}|$, $|E_{\ominus}|$ and $|F_{ALG,\ominus}|+2|E_{\ominus}|$ applications of primitives, respectively, which yields: $ALG_{2}(G_{s},G_{t})\leq 2|F_{ALG,\ominus}|+3|E_{\ominus}|\leq 4|F_{OPT,\ominus}|+3|E_{\ominus}|$ (since $F_{ALG,\ominus}$ is a 2-approximation of $F_{OPT,\ominus}$).

To lower bound the value of $OPT(G^{\prime},G_{t})$, assume for contradiction that there is a computation $C$ with initial graph $G^{\prime}$ and final graph $G_{s}$ of length $L<|F_{OPT,\ominus}|-|E_{\ominus}|$. Let $G_{s}=G_{1}\Rightarrow G_{2}\Rightarrow\dots\Rightarrow G_{L}$ be the sequence of graphs of this computation. Similar to the proof of Lemma 3.5, for every $\{u,v\}\in E_{\ominus}$, we create a path from $u$ to $v$, but this time we start with $P_{u,v}^{1}:=(u,v)$ and consider the graphs in increasing order: For $i\in\{2,\dots,L\}$, if $P_{u,v}^{i-1}$ exists in $G_{i}$, $P_{u,v}^{i}:=P_{u,v}^{i-1}$. Otherwise since $G_{i}$ is the result of a single application of a primitive to $G_{i-1}$, there is exactly one edge $\{x,y\}$ in $P_{u,v}^{i-1}$ that exists in $G_{i-1}$ but not in $G_{i}$ and this edge must have been delegated by either $x$ or $y$ to some node $w$. In the following denote the node that applied the delegation by $z$ and denote by $\overline{z}$ the other node from $\{x,y\}$.In $G_{i-1}$, $z$ must share an edge with $w$ and this edge still exists in $G_{i}$ (for only one primitive is applied in the transition from $G_{i-1}$ to $G_{i}$). Since $\{z,\overline{z}\}$ was delegated by $z$ to $w$, the edge $\{w,\overline{z}\}$ exists in $G_{i}$. Thus, let $P_{u,v}^{i}$ be $P_{u,v}^{i-1}$ with $(x,y)$ replaced by $(x,w,y)$ and observe that $P_{u,v}^{i}$ exists in $G_{i}$. Eventually, we obtain a path $P_{u,v}^{L}$ that exists in $G_{t}$. Define $F^{i}:=\bigcup_{\{u,v\}\in E_{\ominus}}E(P_{u,v}^{i})$ (where $E(P)$ is the set of all edges on the path $P$) as a normal set of edges (i.e., not a multiset) for every $i\in\{1,\dots,L\}$, and note that $F^{L}$ can be transformed into a feasible (though not necessarily optimal) solution to the USF with input $(G_{t},E_{\ominus})$ by removing cycle edges. Therefore, $|F^{L}|\geq|F_{OPT,\ominus}|$. Furthermore, for an arbitrary $i\in\{1,\dots,L-1\}$, note that $|F^{i+1}|\leq|F^{i}|+1$ because there is at most one edge $\{x,y\}$ that exists in $G_{i}$ but not in $G_{i+1}$ and thus causes the replacement of $(x,y)$ by $(x,w,y)$ for some fixed node $w$ for all paths that contain $(x,y)$ as a sub-path. This yields that $|F^{L}|\leq|F^{1}|+L=|E_{\ominus}|+L$ because $F^{1}=E_{\ominus}$ (note the definition of $F^{1}$). By the assumption that $L<|F_{OPT,\ominus}|-|E_{\ominus}|$, we obtain $|F^{L}|<|F_{OPT,\ominus}|$, which represents a contradiction.

3.2 A Constant Approximation Algorithm for DLGT

In this subsection we describe how to adapt Algorithm 1 to obtain a constant approximation algorithm for DLGT. The pseudocode of the adapted version of the approximation algorithm is given in Algorithm 2 (with differences to Algorithm 1 highlighted in boldface). In this pseudocode and in the following proof, for a graph $G=(V,E)$, $U(G)$ denotes the undirected version of $G$, i.e., each edge $(u,v)$ in $G$ is replaced by $\{u,v\}$. An example of the procedure of Algorithm 2 is illustrated in Figure 7.

Algorithm 2 also has a constant approximation factor, which is stated by the following theorem:

Theorem 3.9**.**

$\textsc{DLGT}\in\mathsf{APX}$.

Proof 3.10**.**

We begin with establishing a relationship between solutions to DLGT and to ULGT. For arbitrary directed graphs $G_{s}$ and $G_{t}$, let $C_{d}(G_{s},G_{t})$ be an optimal solution to DLGT with (directed) initial graph $G_{s}$ and (directed) final graph $G_{t}$ (this problem we denote by $P_{d}(G_{s},G_{t})$) and let $OPT_{d}(G_{s},G_{t})$ be its length. Let $C_{u}((U(G_{s}),U(G_{t}))$ be an optimal solution to ULGT with initial graph $U(G_{s})$ and final graph $U(G_{t})$, denote its length by $OPT_{u}((U(G_{s}),U(G_{t}))$, and denote this problem by $P_{u}((U(G_{s}),U(G_{t}))$. Let the computation $C_{u}^{\prime}$ be obtained from $C_{d}$ by ignoring all edge directions and removing all applications of reversal primitives from $C_{d}$. Note that $C_{u}^{\prime}$ is a solution to $P_{u}((U(G_{s}),U(G_{t}))$ and that its length is thus lower bounded by $OPT_{u}((U(G_{s}),U(G_{t}))$ and upper bounded by $OPT_{d}(G_{s},G_{t})$ (since we only shortened the optimal solution to $P_{d}(G_{s},G_{t})$). Therefore, $OPT_{u}((U(G_{s}),U(G_{t}))\leq OPT_{d}(G_{s},G_{t})$ for all directed graphs $G_{s}$ and $G_{t}$. We will use this insight to compare the length of the solution computed by Algorithm 2 for initial graph $G_{s}$ and final graph $G_{t}$ with the length of the solution computed by Algorithm 1 for initial graph $U(G_{s})$ and final graph $U(G_{t})$ in order to prove the claim.

In the following, due to the similarities of Algorithm 2 with Algorithm 1, we only describe the changes to the algorithm that require additional explanation (namely, Step 2 and Step 6). The other changes (highlighted in boldface in Algorithm 2) are self-explanatory. Additionally, we analyze the influence of the differences in the algorithms on the length of the computations.

The procedure for the creation of edges in Step 2 is, in general, very similar to that used in Algorithm 1 (described in the proofs of Lemma 3.5). There are three differences, though: First, in order to delegate / introduce edges downwards in a tree $T$, all edges of $T$ must be oriented downwards, which is why we reverse all edges oriented into the opposite direction (towards $r_{T}$) first. Let $E_{R}$ be the set of all these edges of all trees $T$. Then this additionally involes $|E_{R}|$ applications of the reversal primitive in total. Second, since we deal with directed edges, we have to clarify that the edges delegated / introduced through the tree must be directed towards the root node. Third, this process creates the additional edges $(u,r_{T})$ for every $u$ incident to an edge in $E_{\oplus}$, whereas $(r_{T},u)$ is desired. Thus, for each such edge, we apply the reversal primitive to turn $(r_{T},u)$ into $(u,r_{T})$, which requires at most $2|E_{\oplus}|$ applications of primitives. In Step 4, we additionally have to reverse all edges in every tree first in order to be able to delegate upwards in the tree. This involves $|F_{ALG,\oplus}|$ additional applications of reversal primitives in total. Furthermore, we have to reverse all superfluous edges before we can start the bottom-up procedure. As their number is, again, upper bounded by $2|E_{\oplus}|$, we have to apply only that number of reversal primitives. In addition, we afterwards reverse all edges whose orientation does not yet match their orientation in $G_{s}$, which totally requires an additional $|F_{ALG,\oplus}\setminus E_{R}|$ applications of reversal primitives (since these are exactly the edges in $F_{ALG,\oplus}$ that were not reversed in Step 2). Altogether, the additional number of primitives required in comparison to Algorithm 1 is $|E_{R}|+|2E_{\oplus}|+|F_{ALG,\oplus}|+2|E_{\oplus}|+|F_{ALG,\oplus}\setminus E_{R}|=2|F_{ALG,\oplus}|+4|E_{\oplus}|$ Thus, the length $ALG_{1}^{2}(G_{s},G_{t})$ of the computation computed in the first part by Algorithm 2 is at most $ALG_{1}^{1}(U(G_{s}),U(G_{t}))+4|E_{\oplus}|+2|F_{ALG,\oplus}|$ (in which $ALG_{1}^{1}(U(G_{s}),U(G_{t}))$ is the length of the computation of the first part of Algorithm 1 for initial graph $U(G_{s})$ and final graph $U(G_{t})$).

For the second part, note that the creation of edges in Step 6 is generally very similar to that used in Algorithm 1 (described in the proof of Lemma 3.7). Here, for each edge $(u,v)\in E_{\ominus}$, $u$ corresponds to $s(e)$ in Algorithm 1. As in Step 2, we have to reverse the edges downwards in the tree first, incuring $r$ additional primitive applications. Again, the edges delegated / introduce through the tree must be directed towards the root node. In Step 8, we again have to reverse all edges in each tree, requiring an additional number of primitive applications of $|F_{ALG,\ominus}|$. Additionally, we the edges created in Step 7 need to be reversed, which are $|E_{\ominus}|$ in total. Last, the edges whose orientation does not match their orientation in $G_{t}$ (which are those that were not reversed in Step 6) need to be reversed, which requires $|F_{ALG,\ominus}|-r$ applications of reversal primitives. All in all, the length $ALG_{2}^{2}(G_{s},G_{t})$ of the computation computed in the second part by Algorithm 2 is at most $ALG_{2}^{1}(G_{s},G_{t})+2|F_{ALG,\ominus}|+|E_{\ominus}|$ (in which $ALG_{2}^{1}(U(G_{s}),U(G_{t}))$ is the length of the computation of the second part of Algorithm 1 for initial graph $U(G_{s})$ and final graph $U(G_{t})$).

Incorporating the arguments and results of the proofs of Lemma 3.5 and Lemma 3.7, we obtain:

[TABLE]

where $OPT$ is defined as in Section 3.1.2 and $G^{\prime}=U((V,E_{s}\cup E_{\oplus}))$ for $E_{s}$ being the edge set of $G_{s}$.

Let $ALG^{2}(G_{s},G_{t})$ be the length of the computation computed by Algorithm 2 for initial graph $G_{s}$ and final graph $G_{t}$. Building on the above two inequations, we can apply Lemma 3.3 to obtain

[TABLE]

This finishes the proof.

4 Conclusion

We proposed a set of primitives for topology adaptation that a server may use to adapt the network topology into any desired (weakly) connected state but at the same time cannot use to disconnect the network or to introduce new nodes into the system. So far, we only assumed that the server could act maliciously but that the participants of the network are honest and correct, i.e., they refuse any graph transformation commands beyond the four primitives. What, however, if some participants also behave in a malicious manner? Is it still possible to avoid Eclipse or Sybil attacks? It seems that in this case the only measure that would help is to form quorums of nodes that are sufficiently large so that at least one node in each quorum is honest.

Besides these security-related aspects, our results give rise to additional questions: For example, does the NP-hardness apply to any set of local primitives, or is there a set of local primitives that can transform arbitrary initial graphs much faster into arbitrary final graphs than the set considered in this work? Furthermore, is it possible to obtain decentralized versions of the algorithms presented in Section 3, and, if so, what is their competitiveness when compared to the centralized ones?