Batched Vertex Cover Reconfiguration

Shahar Romem Peled

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Batched Vertex Cover Reconfiguration

Research Thesis

Submitted in partial fulfillment of the requirements for the degree of Master of Science in Computer Science

Shahar Romem Peled

Submitted to the Senate of the Technion — Israel Institute of Technology Adar 5781 Haifa March 2021

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 This research was carried out under the supervision of Prof. Keren Censor Hillel, in the Faculty of Computer Science.

Acknowledgements

I would like to thank my advisor Professor Keren Censor-Hillel for her insightful guidance, patience and academic support. I would also like to thank Tigran Tonoyan and Yannic Maus for their effort and time invested in me. Last but not least, Iwould like to thank my parents, family and friends for their encouragement and comfort given to me.

The generous financial help of the Forchheimer Foundation and the Technion are grate- fully acknowledged.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Contents

List of Figures

Abstract 1

Abbreviations and Notations 3

1 Introduction 5 1.1 Our Contribution ...... 7

2 Related Work 11

3 Background 15

4 Batched Vertex Cover Reconfiguration Schedules 17 4.1 Compression of Sequential Schedules ...... 17 4.2 Degree Based Schedules ...... 21

5 Distributed Computation of Schedules 27 5.1 Reconfiguration on Cactus Graphs ...... 27 5.1.1 Small Separator Decompositions ...... 28 5.1.2 Cluster Merging ...... 31 5.1.3 Computing Small Separator Decompositions on Cactus Graphs . 35 5.2 Distributed Computation of Degree-Based Schedules ...... 38 5.2.1 An O(∆/ε)-Batch Schedule ...... 39 5.2.2 From Bounded Degree to Bounded Arboricity: an O(λ/ε2)-Batch Schedule ...... 41 5.2.3 Computing a Schedule in a Single Round ...... 42

6 Hardness of Schedule Computation 45 6.1 An Ω(n) Lower Bound for Weighted Cycles ...... 45 6.2 An Ω(n) Lower Bound for Unweighted Graphs ...... 49 6.3 An Ω(log∗n) Lower Bound for Unweighted Cycles ...... 53

7 Conclusion and open questions 57

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Hebrew Abstract i

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 List of Figures

5.1 A (d, x, k)-separator decomposition ...... 28

6.1 Segment Ii in G ∈ G ...... 49

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Abstract

Reconfiguration schedules, i.e., sequences that gradually transform one solution ofa problem to another while always maintaining feasibility, have been extensively studied. Most research has dealt with the decision problem of whether a reconfiguration schedule exists, and the complexity of finding one. A prime example is the reconfiguration of vertex covers (sets of vertices that touches all edges in a graph). We initiate the study of batched vertex cover reconfiguration, which allows to reconfigure multiple vertices concurrently while requiring that any adversarial reconfiguration order within a batch maintains feasibility. The latter provides robustness, e.g., if the simultaneous reconfiguration of a batch cannot be guaranteed. The quality of a schedule is measured by the number of batches until all nodes are reconfigured, and its cost, i.e., the maximum size of an intermediate vertex cover. First, we design a black-box compression scheme that for any graph, takes any well-behaved sequential (= non-batched) vertex cover reconfiguration schedule and compresses it into a short batch schedule, while only incurring a 1 + ε multiplicative increase in the cost when using O(1/ε) batches; we show that this is optimal. Second, we show that a similar transformation scheme can be efficiently run in a distributed setting, where computation is done at the vertices. The distributed result is based on the new concept of a small separator decomposition that could be of independent interest. In addition, we show that this approach is optimal, in the sense that if a small separator decomposition does not yield a good schedule, no method will. Both results apply to various graph classes such as chordal graphs and cacti, and provide efficient approximation schemes that have polynomial run-time in the centralized setting and take O(log∗ n/ε) rounds in the distributed setting. Lastly, we propose greedy-style sequential and batch reconfiguration schedules and study their performance for graphs of bounded arboricity. as well as their distributed implementation.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 2

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Abbreviations and Notations

• Throughout the thesis, we denote by [k] the set {0, 1, . . . , k}.

• Throughout the thesis, for sets A, B we denote by A⊕B the symmetric difference of A and B, that is, (A \ B) ∪ (B \ A).

• Given a graph G = (V,E) and a set U ⊆ V , we denote by G[U] = (U, E′) that graph induced by U, that is, E′ = E ∩ (U × U).

• Given a graph G = (V,E), α and β are often used to denote vertex covers of V . In addition, we usually use the notations M = max{|α|, |β|}, D = α ⊕ β, X = α ∩ β, A = α \ β, B = β \ α.

• Given a graph G = (V,E) we denote by ∆ the maximum degree in the graph.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 4

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 1

Introduction

Consider a system of n computers v1, . . . , vn with links {(vi, vj)} between some pairs of them on which they can communicate and share information. For security reasons, we would like to oversee all communication between computers. To this end, we la-

bel a vertex cover of the computers as monitors, that is, every link (vi, vj) between

two computers will have at list one monitoring endpoint, vi or vj. After some time, maintenance is needed for some of the computers, and as those computers cannot mon- itor when maintenance is being done, we need to change the set of monitors. For the same security reasons, all links need to be monitored even when transforming from the first set of monitors to the second one. In addition, as monitoring takes resources, we bound, by some integer k, the allowed number of monitors at any given time, including monitoring sets that occur during such a transformation. The task in the above paragraph is not always possible, e.g., if k is smaller than the monitoring sets themselves. Those types of problems are known as reconfiguration problems, which ask the following type of questions: Given two solutions to a problem, is it always possible to gradually move from one solution to the other by changing one element at a time, while always maintaining a feasible solution? Reconfiguration problems thus explore reachability in a graph over the solutions, and as such they have been extensively studied for various problems. Notable examples are colorings [CvdHJ08, IKD12, BHI+20], matchings [IKK+19], independent sets and vertex covers [KMM12, LM19]. A well-studied example is vertex cover reconfiguration, which is exactly the problem described in the ”monitoring machines” example, and is also the focus of this thesis. In this task, one needs to find a schedule that moves from a given first vertex cover (i.e.,a subset of the vertices that touches all edges) to a given second vertex cover by changing the membership of one vertex at a time, and while ensuring that each intermediate set is a valid vertex cover (feasibility). Traditionally, the emphasis has been on the size of the intermediate solutions—the problem is trivial with no size bound—while the elementary steps consist of adding or removing a single vertex. Our goal is to exploit parallelism for reconfiguration schedules, which is natural

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 in settings where the state of vertices can be changed concurrently. For vertex cover reconfiguration, this leads us to allow changing the membership in the intermediate set of more than one vertex in each step. To study this setting, we introduce the concept of batch reconfiguration.

Batch reconfiguration. In batch reconfiguration, one is allowed to change a batch of an unbounded number of elements in a single reconfiguration step, as opposed to the previous sequential reconfiguration, which changes a single vertex at a time. However, such a solution is not practically robust, in the following sense: Suppose that implementing the change for a vertex is not an immediate operation and could rather take a bit of time. Then, changing several vertices concurrently may result in a sequence of changes in these vertices, with an unpredictable order. As a result, although we aim at reconfiguring all vertices at once in one swipe, in reality what could happen is that we get an arbitrary sequence of changes, which can easily violate feasibility in an adversarial execution of a batch. In light of the above, in addition to feasibility, we require a robustness condition for batch reconfiguration schedules. The goal of a robustness condition is to guarantee that no matter in which order the elements of a batch are eventually executed, feasibility is never violated. We require that the set of vertices that are reconfigured within a batch is always an independent set. This promises that each edge is always covered, also within any internal ordering of a batch.

The tradeoff between the number of batches and the solution size. When computing a schedule between two covers, typically denoted by α and β, batching brings the advantage of short schedules, but comes with a proportional overhead in solution sizes. We show via a pigeonhole argument that for some instances of vertex covers α and β, every reconfiguration schedule with t batches necessarily creates an intermediate solution of size at least (1 + 1/t) · max{|α|, |β|}. We desire to get as close as possible to this optimal length-vs.-size tradeoff. We evaluate the quality of a batch reconfiguration schedule for vertex cover by two measures: the length of the schedule, i.e., the number of batches, and the maximum size of an intermediate vertex cover in the schedule, which, by the robustness condition, includes all possible intermediate vertex covers that can occur in any internal ordering of each batch. In view of the natural barrier of max{|α|, |β|} on the worst-case intermediate vertex cover size, as well as the necessary overhead given by batch schedules, we say a reconfiguration schedule is an (η, c)-approximation if the size of the worst-case intermediate cover is at most η · max{|α|, |β|} + c (see Chapter 3 for formal definitions). Here, η is between 1 and 2, and is normally related to the number of batches, while c is often a constant (e.g., the trivial 2-batch schedule that adds all nodes in β \ α, then removes all nodes in α \ β, is a (2, 0)-approximation for a schedule from α to β).

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 1.1 Our Contribution

We introduce the concept of batch reconfiguration of vertex covers. Our first technical contribution is a black-box compression scheme that mechanically transforms a sequential schedule into a batched one of desired length, with a proportional and unavoidable overhead. Thus, we derive batch schedules from known sequential schedules. Our result holds for monotone schedules, that never touch a vertex twice, which is aligned with prior work.

Theorem 1.1 (Schedule Compression). Let G = (V,E) be a graph with two vertex covers α, β, and let S be a monotone sequential schedule from α to β that is an (η, c)- approximation, for a real η ≥ 1 and an integer c ≥ 0. For every ε ∈ (0, 1), S can be transformed into a monotone (2⌈1/ε⌉)-batch schedule S′ that is an (η + ε, c + 1)- approximation.

Based on known results, we know that cactus graphs have (1, 2)-approximation schedules [INZ16] (see Theorem 4.1). Our batching scheme transforms these schedules into (2⌈1/ε⌉)-batch schedules.

Theorem 1.2. Let ε > 0. Let G = (V,E) be a graph with a pair α, β of vertex covers. If G belongs to one of the graph classes {cactus, chordal, even-hole-free, claw-free}, there is a monotone (2⌈1/ε⌉)-batch (1 + ε, 3)-approximation schedule from α to β.

We show in Section 4.1 that the tradeoff between the number of batches and the approximation overhead in Theorem 1.1 is (almost) the best possible. This implies that the batch schedules from Theorem 1.2 are nearly optimal in terms of the length vs. approximation tradeoff. In Section 4.2 we ask if the (1 + ε)-type approximations á la Theorem 1.2 can be extended to graphs of bounded degree or bounded arboricity graphs1. We show that the answer to this question is negative: for any d > 0, there are infinitely many d-regular expander graphs G√ with two vertex covers α, β, for which no schedule can be better than a (2 − O(1/ d))-approximation. On the positive side, we give a (2 − Ω(1/λ))- approximation for any graph of arboricity λ, by an extremely simple monotone degree- based schedule that reconfigures α-nodes in an increasing degree order. These results are summarized in the following theorem.

Theorem 1.3. For every d ≥ 4, there is an infinite sequence of d-regular graphs G , i ≥ ( √ ) i 1, with vertex covers αi, βi, that do not admit 2 − 4/( d + 1 + 1), 0 -approximation schedules. Any graph G of arboricity λ with vertex covers α, β has a (2 − 1/2λ, 1)- approximation schedule.

Afterwards, we take advantage of the simplicity of the degree-based schedule and show that it can be compressed into a 4-batch schedule with a similar approximation.

1The arboricity of a graph is the minimum number of forests that are needed to cover its edge set.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 We note that this compression is tailored for degree-based schedules and cannot be applied in a black-box manner as Theorem 1.1.

Theorem 1.4. Let G = (V,E) be a graph with two vertex covers α and β such that the graph induced by D = α⊕β has arboricity λ. The 4-batch schedule is a (2−1/(2λ+1), 1)- approximation.

Distributed computation of reconfiguration schedules. A natural setting where batch reconfiguration may appear is when nodes themselves, as distributed au- tonomous computers, execute a reconfiguration schedule by exchanging information with others. This immediately raises the question of computing schedules in such distributed settings (distributed reconfiguration has also been studied for colorings [BOR+18] and independent sets [CR19]). We focus on the LOCAL model of distributed computing, where nodes synchronously send messages to their neighbors in the underlying network graph (which also serves as the problem instance), and give efficient algorithms for computing batch schedules. At the core of most of our algorithmic results is a graph decomposition, that we call a small separator decomposition. Roughly speaking (and hiding many technical details), it is a decomposition into small diameter clusters and a small separator set S (e.g., an ε fraction of |α| + |β|, for a small ε > 0), such that there are no inter- cluster edges. At a very high-level, we show that if there exists a good approximation schedule for each cluster, we can compute a batch schedule for the whole graph with only a small approximation overhead and in a number of rounds that is linear in the maximum cluster diameter.

Theorem (Informal version of Theorem 5.5). Let G = (V,E) be a graph with two vertex covers α and β, and a small separator decomposition with a separator set S and k k clusters (Ci)i=1 of diameter d. If each subgraph G[Ci] admits a monotone ℓ-batch (η, c)-approximation schedule, then a (2ℓ+2)-batch (η, |S|+k·c)-approximation schedule for α and β can be computed in O(d) rounds in the LOCAL model.

We stress that a naïve simultaneous reconfiguration of two clusters of a given small separator decomposition, both with a (1 + ε)-approximation schedule, might actually increase the global approximation guarantee (see Remark 5.4), and so, a more sophisticated approach in using small separator decompositions is needed to prove Theorem 5.5. As can be seen in the theorem above, it is crucial to have a graph decomposition both with a small size separator, as well as few clusters. Our main technique for computing small separator decomposition is inspired by the well-known GHS and GKP algorithms for the distributed computation of a minimum-weight spanning tree [GHS83, GKP98]. For some special graph classes, we show that small separator decompositions can be computed super-fast (i.e., in O(log∗ n)-rounds). This holds in particular for cactus graphs. More concretely (see Lemma 5.10), there is a super-fast distributed algorithm

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 that for any connected graph G and vertex covers α, β such that α ⊕ β induces a cactus graph, computes a small separator decomposition with few clusters. The property “G[α ⊕ β] is a cactus graph” holds for all graphs G in the following graph classes {cycles, trees, forests, chordal, cactus, even-hole-free, claw-free}. For such graphs G, we have (1, 2)-approximation schedules [INZ16]. Together with Theorem 5.5 and Lemma 5.10, this implies the following theorem. Theorem 1.5 (Cactus Reconfiguration). For each ε > 0, there is a LOCAL algorithm that for any connected n-node graph G and vertex covers α and β such that G[α⊕β] is a cactus graph, computes a O(1/ε)-batch (1 + ε, 3)-approximation schedule in O(log∗n/ε) rounds.

We also show that the runtime of Theorem 1.5 is asymptotically tight; see Theo- rem 6.11. The next theorem provides super-fast algorithms to compute batch schedules for general graphs, at the cost of an increased approximation factor and schedule length. Theorem 1.6. Let G be a graph with vertex covers α and β, such that G[α ⊕ β] has arboricity at most λ, with λ known to all nodes. For every ε > 0, there exists a ( ) O(log∗ n/ε)-round LOCAL algorithm that computes a O λ/ε2 -batch (2 − 1/2λ + ε, 1)- approximation schedule from α to β.

Theorem 1.6 is based on the simple degree-based schedule from Theorem 1.3, which also shows that in general, the obtained schedules cannot be improved by much (even sequentially). We further show that a degree-based schedule can be computed even faster, but with the cost of having a much longer schedule. The algorithm uses a bound f(n) on the largest identifier of a node inan n-node graph. Theorem 1.7. Let G = (V,E) be an n-node graph with arboricity λ and two vertex covers α and β. There exists a 1-round LOCAL algorithm that computes an O(∆f(n))-batch (2 − 1/2λ, 1)-approximation schedule from α to β, when f(n) is the largest identifier among the nodes in the graph and is known to all nodes.

Theorem 5.5 suggests that if every cluster in the decomposition admits a good reconfiguration schedule, one can compute a good schedule for the whole graph efficiently. We show that this condition is necessary, in the following strict sense: there are graphs for which there exist good schedules, and they can be quickly decomposed, but just because some clusters do not have good schedules, no sub-linear distributed algorithm can compute a good schedule. Theorem (Informal version of Theorem 6.6). For each ε ∈ (0, 1), there is an infinite family G of graphs such that every graph in G admits a (1 + ε)-approximation schedule, but no o(n)-round deterministic distributed algorithm can compute a (2 − ε)- approximation schedule.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 10

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 2

Related Work

Reconfiguration problems have long been studied under various guises (e.g., inthe form of puzzles [HD05]), but a more systematic study has appeared rather recently, in [IDH+11]. The high-level picture of the area is that for NP-complete source problems, the reconfiguration variants are usually PSPACE-complete [IDH+11, BC09, HD05], although there are exceptions to this trend [JKK+16]. There are three models that have been considered for vertex cover reconfiguration. The first model, which is the one we adopt in this thesis, is Token Addition/Removal (TAR), where we have an initial pair of solutions (possibly of different sizes), and

two intermediate solutions S1 and S2 are adjacent if S2 is obtained from S1 by either removing or adding a single vertex. Without any further constraints, the question of whether one can go from one solution to another is trivial, as one could always go from one vertex cover to the whole set of vertices then to the target one. Thus, we usually constrain either the maximal size of an intermediate vertex cover, or the number of intermediate solutions (i.e., the schedule length), or both. The other two models are Token Sliding (TS) and Token Jumping (TJ), where the

two initial solutions must be of equal size, and two intermediate solutions S1 and S2

are adjacent if S2 is obtained from S1 by swapping a vertex v in S1 with another one, u, which is arbitrary in TJ and must be a neighbor of v in TS. It was observed in [KMM12] that TJ is equivalent to TAR with the constraint that the initial solutions are of equal size k and no intermediate solution is larger than k + 1. In [dBJM18], an extension of TJ was considered, where two solutions are adjacent if one is obtained from the other by a number j ≥ 1 simultaneous TJs. The trend of hardness persists in vertex cover reconfiguration too. Here, the decision problem is: given two vertex covers of size at most k, is there a reconfiguration schedule transforming one into the other via TAR, and without ever having a vertex cover of size more than k + 1. The problem is PSPACE-complete even in usually tractable graph classes such as perfect graphs [KMM12], graphs of bounded pathwidth or bandwidth [Wro18], and planar graphs of degree at most 3 [HD05]. It is also NP-complete for bipartite graphs [LM19]. Table 2.1 [Nis18, Table 1] depicts some of the known results

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 for vertex cover/independent set reconfiguration, we also refer the reader to[Nis18, Figure 5] for a nice graphic depiction of the complexity landscape of the problem.

Table 2.1: Results on reachability for vertex cover/independent set reconfiguration; question marks indicate problems for which there are no known complexity results. [Nis18, Table 1] Class Source TS TAR/TJ planar (of degree 3) NP-complete PSPACE-complete [KMM12] PSPACE-complete [KMM12] even-hole-free ? ? P [KMM12, INZ16, MNRS18] perfect P PSPACE-complete [KMM12] PSPACE-complete [KMM12] cograph P P [KMM12] P [Bon16, BB14] claw-free P P [BKW14] P [BKW14] bipartite P PSPACE-complete [LM19] NP-complete [LM19] bounded treewidth P PSPACE-complete [Wro18] PSPACE-complete [Wro18] bounded pathwidth P PSPACE-complete [Wro18] PSPACE-complete [Wro18] bounded bandwidth P PSPACE-complete [Wro18] PSPACE-complete [Wro18] cactus P P [HU16] P [MNRS18]

On the positive side, the vertex cover reconfiguration schedule existence problem is known to be polynomially solvable for several graph classes, such as trees and cactus graphs [MNRS18, BKW14, DDFE+15, HU16, KMM12]. More relevant to our work, it is known that there are approximation-style schedules in cactus graphs, such that in all intermediate solutions, the size of the vertex cover is bounded by the larger of the two initial ones, plus 2 [MNRS18, KMM12]. While seemingly quite specialized, these results give schedules with similar guarantees for wider classes of graphs, such as even-hole-free graphs (that is, graphs without an induced even cycle), which include chordal graphs and cographs. In the same spirit, it is shown in [dBJM18] that there are schedules in general graphs that increase the maximum vertex cover by at most the pathwidth of the graph. All these schedules are monotone, i.e., every vertex changes its status at most once. This is the case with all schedules in this thesis as well. In fact, [LM19] show that when the two vertex covers in a reconfiguration instance are disjoint, there always exists a monotone schedule.

Distributed Reconfiguration. The task of reconfiguration have already been asked in a distributed setting as well. First, the task of recoloring (i.e. reconfiguration of colorings) has been considered [BOR+18]. In short, given integers k and c, a k + c recoloring problem is the task of transforming an input k-coloring α into another given k-coloring β, while maintaining a k +c-coloring in any intermediate step. In [BOR+18], efficient LOCAL algorithm were presented for 3 + 1 recoloring schedules on trees and graphs of degree at most 3, as well as a lower bound of Ω(n) for computing 3 + 1 recoloring schedules on toroidal grids. Another problem researched is the one of reconfiguration of maximal independent

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 sets [CR19]. There, it was shown that for any graph with a diameter greater that 3, there exists an schedule of constant length, which maintains a (2, 4)-ruling set (i.e. a set S ⊆ V for which every two nodes are at distance at least 2 and every node outside S is within distance at most 4 from S) in the intermediate steps and can be computed efficiently in the LOCAL model.

Distributed Constructions. Computing a minimum vertex cover is a funda- mental problem which is known to be hard both in a centralized setting (NP-hard) as well as in a distributed one (Ω(D) lower bound for a graph with diameter D). ( ) A d(n), c(n) -network-decomposition of an n-node graph G = (V,E) is a partition of V into clusters such that each cluster has weak diameter at most d(n) and the cluster-graph is properly colored with colors 1, . . . , c(n). Using algorithms for computing network decomposition, the work presented in [GKM17a] showed that there exists a randomized O(poly(log n/ε)) algorithm for finding an (1 + ε)-approximation (with high probability) and the results given in [RG20] have proven that there is also a deterministic O(poly(log n/ε)) algorithm yielding the same approximation factor. Another task important for our results is the computation of a Minimum Spanning Tree in a distributed system. In the CONGEST model, this problem is solved by the well-known GHS and GKP algorithms [GHS83, GKP98]. The GHS algorithm is an O(m + n log n)-round algorithm for computing an MST on an n-node graph with m √ edges, where the GKP has a run-time of (D + nlog∗n) rounds. The techniques used in the GHS and GKP algorithms have inspired the main tool (Lemma 5.7) for many of our positive results in the distributed part of this thesis.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 14

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 3

Background

Vertex Cover Reconfiguration Schedules

A vertex cover in a graph G = (V,E) is a subset S ⊆ V such that every edge e = (u, v) ∈ E has at least one of its end-vertices in S. An independent set is a subset S ⊆ V of vertices such that every edge has at most one of its end-vertices in S. Note that if S is a vertex cover then V \ S is an independent set, and vice versa. We use the notation [x] = {0, 1, . . . , x}, for an integer x ≥ 0. For sets A, B, we let A ⊕ B = (A \ B) ∪ (B \ A) denote their symmetric difference.

Definition 3.1 (Vertex Cover Reconfiguration Schedule). Given a graph G = (V,E) and two vertex covers α, β ⊆ V (not necessarily minimal), a reconfiguration schedule

S from α to β of length ℓ and cost s is a sequence (Vi)i∈[ℓ] of vertex covers of G such that:

1. V0 = α and Vℓ = β,

2. ∀i ∈ [ℓ − 1], |Vi ∪ Vi+1| ≤ s,

3. ∀i ∈ [ℓ − 1],Vi ⊕ Vi+1 is an independent set of G.

The sets Ei := Vi ⊕ Vi+1, which we call batches, contain the vertices that are added to or removed from the current vertex cover in order to obtain the next one. Thus, we also refer to a length ℓ schedule as an ℓ-batch schedule. A reconfiguration schedule is

sequential if |Ei| = 1, for all i ∈ [ℓ − 1], and a batch schedule otherwise. A schedule S from α to β is monotone if every node v ∈ V is changed at most once in the schedule. Note that a monotone schedule S only changes nodes in α ⊕ β, and therefore its length (if there are no empty batches) is always |α ⊕ β|. In particular, a monotone schedule does not change nodes in α ∩ β. The first property of Definition 3.1 ensures that S is a reconfiguration schedule from α to β. The second and third properties combined ensure robustness, in the sense that

not only (Vi)i∈[ℓ] are vertex covers of size at most s, but any reconfiguration sequence between Vi and Vi+1 yields vertex covers with the claimed size bound. Note that when

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 in each reconfiguration step we only add or remove nodes, property 2 reduces to having

|Vi| ≤ s for all i ∈ [ℓ].

For η, k ∈ R+, a reconfiguration schedule from a vertex cover α to a vertex cover β is an (η, c)-approximation if its cost is at most η max{|α|, |β|} + c. Note that here we do not compare to the cost of an optimal reconfiguration schedule but rather to M = max{|α|, |β|}; the cost of an optimal schedule is always at least M, but often it is larger than M. We observe that there is an inherent symmetry in the reconfiguration schedules from α to β and the schedule from β to α, this is formalized in Observation 3.2.

Observation 3.2 (Reverse Schedule). Let S = (Vi)i∈[ℓ] be a vertex cover reconfigura- S′ ′ tion schedule of cost s from α to β in graph G. Then the reverse schedule = (Vi )i∈[ℓ], ′ where Vi = Vℓ−i, is a vertex cover reconfiguration schedule of cost s and length ℓ from β to α.

Graph Classes and Properties

A graph is even-hole-free if it contains no induced cycle with an even number of vertices. A graph is chordal if it contains no induced cycle with 4 or more vertices (in particular,

it is even-hole-free). A graph is claw-free if it contains no induced K1,3 sub-graph. A graph is a cactus graph if each of its edges belongs to at most 1 cycle. Alternatively, cactus graphs are characterized by a forbidden minor, the diamond graph, which is

obtained by removing an edge from K4; thus, they form a minor-closed family. The arboricity of a graph G = (V,E) is the minimum number of forests that are needed to cover the edge set E. Alternatively,⌈ the arboricity⌉ equals the maximum |E(G[U])| density of a subgraph, i.e., λ = maxU⊆V,|U|≥2 |U|−1 [NW64].

The LOCAL Model of Distributed Computing [Lin92, Pel00]

A network of computing machines are modeled as an undirected graph G = (V,E), |V | = n, where each node v ∈ V in the graph represents a machine, and each edge

(vi, vj) ∈ E represents a bidirectional communication link. Communications happen in synchronous rounds, where in each round, every node sends a single message of unbounded size to each of its neighbors, receives messages from them, and performs a computation. Initially, each node is aware only of its neighbors, receives a unique ID from a space of size poly n, and possibly some additional input. In the computation, we assume that every node is infinitely powerful, meaning that every local computation happens immediately, and assume that the system is fault free, i.e., nodes do not crash and messages are always sent immediately. We say that the nodes of the graph G compute a solution, if each node v ∈ V knows its own part of the solution. For example, we say that the nodes compute a coloring, if every node knows its own color and the coloring of the entire graph is valid.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 4

Batched Vertex Cover Reconfiguration Schedules

Throughout this chapter, we consider batched vertex cover reconfiguration schedules in a centralized system. In Section 4.1, we show that sequential schedules can be compressed into short batch schedules while only incurring a small additional cost. Afterwards, we show that for several graph classes our batching is essentially optimal. Then, in Section 4.2 we study a “greedy” sequential reconfiguration schedule based on the degree distribution of the vertices in the graph, and analyze its performance in terms of the arboricity of the graph. In the second part of Section 4.2 we compress such a degree based schedule even further and beyond the results of Section 4.1 to obtain an extremely short schedule. Finally, we show that the obtained approximation cannot be improved much for bounded arboricity graphs.

4.1 Compression of Sequential Schedules

Assume that for some graph G with two vertex covers α and β, there exists a sequential

monotone (1, 1)-approximation schedule S of length ℓ. Let v1 be the first β-node to be

added. When adding v1 to α, we get a vertex cover of size |α| + 1. Therefore, the first

α-node u1 in S can be removed (since S is a (1, 1)-approximation schedule and thus we

know that S does not add another β-node before removing u1). A more sophisticated

analysis shows that after adding the first k β-nodes v1, . . . , vk to the vertex cover one

can remove the first k α-nodes u1, . . . , uk while keeping every edge covered. Then (with the same argument) one can continue alternating between adding k β-nodes and removing k α-nodes until all nodes are reconfigured. The length of the new compressed batch schedule is O(ℓ/k), with a worsened approximation of (1, k). Generalizing the idea of the above discussion, we give a formal meaning to the notion of compressing a long sequential schedule into a short batch schedule, while bounding the added cost we incur in the approximation.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Theorem 1.1 (Schedule Compression). Let G = (V,E) be a graph with two vertex covers α, β, and let S be a monotone sequential schedule from α to β that is an (η, c)- approximation, for a real η ≥ 1 and an integer c ≥ 0. For every ε ∈ (0, 1), S can be transformed into a monotone (2⌈1/ε⌉)-batch schedule S′ that is an (η + ε, c + 1)- approximation.

Proof. If |β \ α| = 0 the claim immediately follows by removing all vertices in |α \ β| in a single batch. Otherwise, note that the schedule S only reconfigures vertices in ⊕ S |α\β| S |β\α| α β and only adds/removes each vertex once. Let α = (ui)i=1 and β = (vi)i=1 be schedule S restricted to vertices of α and β, respectively, without changing their

order (formally Sα and Sβ consist of the vertices in the singleton batches of S). Define three positive integers

s = ⌈ε|β \ α|⌉, r = ⌊ηM⌋ + c − |α| + s, and ℓ = ⌈(max{|β \ α| − r, 0})/s⌉.

′ The schedule S consists of 2ℓ+2 batches E0, E1,..., E2ℓ+1, where in the first batch

we add the first r vertices from β \ α, according to Sβ, then in every subsequent couple of batches we remove s vertices from α\β and then add s vertices from β \α, according

to Sα and Sβ. In the final batch E2ℓ+1, we remove the remaining vertices, if any, from α \ β. We introduce notation to define the schedule formally. Given i < j, denote by

[ui, uj] and [vi, vj] the sets {ui, ui+1, . . . , uj} and {vi, vi+1, . . . , vj}, respectively, with

the convention [ui, uj] = ∅ if i > |α \ β| (resp. [vi, vj] = ∅ if i > |β \ α|), and | \ | | \ | [ui, uj] = [ui, u|α\β|] if[ j > α β (resp.] [u[i, uj] = [ui, u|β\α|]] if j > β α ). Define E = [v , v ], E − = u , u , E = v , v , for i = 1, 2, . . . , ℓ, and 0 1[ r 2i 1 ] (i−1)s+1 is 2i r+(i−1)s+1 r+is E2ℓ+1 = uℓs+1, u|α\β| .

The schedule S′ is monotone, as each node appears in S′ the same amount of times ′ it appears in S. We next reason that we add all vertices of β \ α in S . In batch E0 we add r vertices of β \ α, and if ℓ > 1 (which doesn’t happen only if r ≥ |β \ α|), in

batches E2, E4 ..., E2ℓ we add s vertices per batch. In total, these are r + ℓ · s ≥ |β \ α| vertices. With r ≥ s and the definition of ℓ, we upper-bound the number of batches of S′ by ⌈ ⌉ r≥s ⌈ ⌉ s=⌈ε|β\α|⌉ ⌈ ⌉ ≤ ⌈ ⌉ |β\α|−r ≤ |β\α| ≤ 1 either 2 2 1/ε (if ℓ = 1) or by 2ℓ + 2 = 2 s + 2 2 s 2 ε .

Approximation. After the first batch, the vertex cover is ofsize |α|+r = ⌊ηM⌋+ c+s ≤ (η +ε)M +c+1. Afterwards, as long as we remove s α-nodes and then add s β- nodes in each batch, the size of the vertex cover never goes above (η+ε)M +c+1. If we add fewer than s β-nodes but remove s α-nodes the size of the vertex cover decreases. If we, in some batch, remove less than s α-nodes we have removed all vertices in α\β and the output is a subset of β, that is, we trivially satisfy the approximation guarantee.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Validity. Lastly, we show that all edges are covered after each reconfiguration step and that each batch is an independent set. Assume for contradiction that i is an ′ index such that, in schedule S , node ui ∈ Sα is removed and it has a neighbor vj ∈ Sβ ′ which was not yet added to the vertex cover in S (in particular, vj could be in the

same batch with ui). This implies that j ≥ r + i − (s − 1), and that in S, right after the addition of the j-th β-node, the i-th α-node has not been removed. Thus, j nodes have been added and at most i − 1 nodes were removed, i.e., the size of the vertex cover is

|α| + j − (i − 1) ≥ |α| + r + i − s + 1 − i + 1 = |α| + r − s + 2 = ⌊ηM⌋ + c + 2 > ηM + c .

This is a contradiction to the assumption that S is a (η, c)-approximation schedule. ′ ′ Hence, for a node v ∈ Ei′ ∩ α, all of its neighbors must be in Ej′ ’s with j < i , implying that every set in S′ is indeed a vertex cover. This, in particular, shows that for every

u ∈ Ei′ ∩α and v ∈ Ei′ ∩β it holds that (u, v) ∈/ E. Together with the fact that Ei′ ∩α\β

and Ei′ ∩ β \ α are independent sets, this shows that every Ei′ is an independent set for all i′ ∈ [ℓ]. ■

To apply Theorem 1.1, we need sequential schedules, an important example is the following result, proven in [INZ16].

Theorem 4.1 ([INZ16]). Let G be a graph with vertex covers α, β. If G is a cactus graph, there exists a monotone (1, 2)-approximation schedule from α to β.

For trees, the additive 2 can be replaced with additive 1 [INZ16, MNRS18]. More- over, the theorem applies not only to the mentioned class, but also to graphs G for which G[α ⊕ β] is a cactus graph.

Observation 4.2. Let G = (V,E) be either a chordal graph, an even-hole-free graph or a claw-free graph with vertex covers α and β, then G[α ⊕ β] is a cactus graph.

The proof exploits the fact the G[α ⊕ β] is bipartite and the properties of the graph class to show that every connected component of G[α ⊕ β] is either a tree (for chordal and even-hole-free graphs) or has a maximum degree 2 (for claw-free graphs).

Proof. Let D = α⊕β. Note that α\β and β \α are independent sets (as a complement of a vertex cover), and so, G[D] is bipartite. First, assume that G is either chordal or even-hole-free. Since G[D] is bipartite, it has no odd cycles, and since it is also even- hole-free (chordal graphs are also even-hole-free), it contains no even cycles. Therefore G[D] does not have cycles, i.e., it is a forest. Now assume that G is a claw free graph and assume that there exists a node v with

degree at least 3 with neighbors u1, u2, u3. The graph induced by {v, u1, u2, u3} is a

claw (since there are no edges between the ui nodes as G[D] is bipartite), which is a contradiction to G being claw-free. Therefore, every node in D has a degree at most 2, and this shows that each connected component is either a path or a cycle. ■

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 We now combine Observation 4.2 with Theorem 4.1 to show that chordal graphs, even-hole-free graphs and claw-free graph admit (1, 2)-approximation schedules as well.

Corollary 4.3. Let G = (V,E) be a graph with a pair α, β of vertex covers. If G belongs to one of the graph classes {cactus, chordal, even-hole-free, claw-free}, there is a monotone (1, 2)-approximation from α to β.

Proof. By Observation 4.2, G[α ⊕ β] is a cactus graph, and so, G[α ⊕ β] admits a monotone (1, 2)-approximation schedule S from α \ β to β \ α. Consider S in terms of the edit sequence and this that this is also a (1, 2)-approximation schedule from α to β in G. The monotonicity and approximation promise of the schedule are immediate. For the validity, see that all edges are covered:

• If both endpoints of (u, v) ∈ E are in G[α ⊕ β], this follows from the validity of S for G[α ⊕ β], and by the monotonicity of the schedule, (u, v) is always covered.

• If (u, v) ∈ E has an endpoint in V \ (α ⊕ β), then one of the endpoints must be in α ∩ β. Assume for contradiction that this is not the case. Therefore, there must be an endpoint v such that v ∈ V \ (α ∪ β), as both α and β are vertex covers, we must have u ∈ α as well as u ∈ β and so, u ∈ α ∩ β. ■

Applying Theorem 1.1 to the above sequential schedules gives extremely short batch schedules with a minor approximation overhead, as follows.

Proof. By Corollary 4.3, G admits a monotone (1, 2)-approximation schedule from α to β, and by Theorem 1.1, it has a (2⌈1/ε⌉)-batch (1 + ε, 3)-approximation schedule.■

Using an application of the pigeonhole principle, we show below that both Theo- rem 1.2 and Theorem 1.1 are nearly optimal, in the sense that a general compression theorem cannot prove a better trade-off between approximation overhead and schedule length.

Theorem 4.4 (Batch Lower Bound). For any 1 ≤ t < n, there is a tree with 2n vertices and vertex covers α, β such that every (t + 1)-batch( reconfiguration) schedule 1 from α to β does not have an approximation better than a 1 + t , 0 -approximation.

Proof. Consider a path graph on 2n vertices, represented as a bipartite graph G = (A ∪ B,E) with |A| = |B| = n. Then both A and B are minimal vertex covers in G.

Consider any (t + 1)-batch reconfiguration schedule S with batches E0, E1,..., Et from A to B. It is easy to translate S into a refined schedule with the same approximation E′ E′ E′ E′ ⊆ E′ ⊆ ratio and at most 2t batches, 0, 1,..., 2t, such that for each i, i A or i B.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Let E′ ,..., E′ be the batches that are contained in B. Since ∪t E′ = B, there is i1 it j=1 ij an index j, such that |E′ | ≥ |B|/t = n/t. Note that before adding E′ to the current ij ij vertex cover, the vertex cover had size at least n (the size of a minimum vertex cover), hence after adding it, we have a vertex cover of size at least n(1 + 1/t), which proves the claim. ■

4.2 Degree Based Schedules

In this section, we prove Theorem 1.3. The proof is presented in two parts. First, we present the algorithm, as well as its batched variant, consisting of 4 batches (The- orem 1.4). Then, we present the impossibility result (Theorem 4.9). We restate the theorem.

Recall, that the arboricity of a graph G = (V,E) is the minimum number of forests that are needed to cover the edge set E. Alternatively,⌈ the arboricity⌉ equals the max- |E(G[U])| imum density of a subgraph, i.e., λ = maxU⊆V,|U|≥2 |U|−1 [NW64]. Consider a graph G with two vertex covers α and β. Here we consider the performance of the following natural monotone sequential degree-based schedule. Since we deal with monotone schedules, we focus on a schedule from A = α \ β to B = β \ α.

Sequential degree-based schedule. The schedule iterates over the vertices in

A in an increasing order v1, v2,... of their degree in G[A∪B] (breaking ties arbitrarily), for each vertex, adds all its neighbors (one by one) to the vertex cover, if they are not already in the cover, and then removes it from the current cover. We first express the cost of the schedule in terms of the parameters ofthegraph G[A ∩ B], particularly the number of vertices and edge density, then we show that this leads to an approximation in terms of the arboricity of G. We will make use of the following simple fact.

≤ ≤ ≤ · · · ≤ Fact 4.5. For any non-decreasing∑ sequence∑ 0 a1 a2 an of non-negative k a n a ≤ ≤ i=1 i ≤ i=1 i reals and index 1 k n, k n .

Lemma 4.6. Let G = (V,E) be a graph with two vertex covers α and β such that the graph induced by D = α⊕β has h > 0 edges. Then the cost of the degree-based schedule | ∩ | | | | | − |A||B| \ \ is at most α β + A + B h + 1, where A = α β and B = β α.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Proof. Any monotone reconfiguration schedule from α to β in G (including the degree- based one) is equivalent to (has the same batch sequence as) a monotone reconfiguration schedule from A to B in G[D]. The two schedules only differ by additive |X| in cost, where X = α ∩ β. Thus, we will consider the degree-based schedule as a schedule

S = (Vi)i∈[|D|] for A and B in G[D], which gives us the corresponding schedule S =

(Vi ∪ X)i∈[|D|] for α and β. The cost of the schedule (from A to B) is the size of the vertex cover (in G[D])

obtained at a step with index 1 ≤ i < |D| such that in the next step i + 1, a vertex vi

is removed from Vi. Note that there can be more than one index which realize the cost

of the schedule. Fix any such i and let Ai be the vertices added until batch i and Bi

the vertices removed until batch i (both times inclusive). Note that N({vi} ∪ Ai) = Bi. Then, using Fact 4.5, we have: ∑ ∑ |B | ∈ ∪{ } dG[D](v) ∈ d (v) h i ≤ v Ai vi ≤ v A G[D] = , |Ai| + 1 |Ai ∪ {vi}| |A| |A|

implying that |Ai| ≥ |Bi||A|/h−1. The cost of the schedule just after batch i is bounded by ( ) |A| |A||B| |V | = |A| − |A | + |B | ≤ |A| + |B | 1 − + 1 ≤ |A| + |B| − + 1 . i i i i h h

We obtain the claimed cost by adding the size of α ∩ β to this bound. ■

Lemma 4.6 combined with the bound on the number of edges in a graph with arboricity λ yields the following theorem, which gives the positive half of Theorem 1.3. Theorem 4.7 (Degree-Based Schedule). Let G = (V,E) be a graph with two vertex covers α and β such that the graph induced by D = α ⊕ β has arboricity λ. The − 1 degree-based schedule is a (2 2λ , 1)-approximation. Proof. Let |A|, |B| and h as in Lemma 4.6 and let M ′ = max{|A|, |B|}, m′ = min{|A|, |B|} ∩ | | ′ ′ − m′M ′ and X = α β. By Lemma 4.6, the schedule has cost X + M + m h + 1. Since G[D] is a graph with m′ + M ′ nodes, h edges, and arboricity λ, we have that ≥ h ≤ ′ ′ − ≤ ′ ′ | | λ m′+M ′−1 , hence h λ(m + M 1) 2λM . Thus, recalling that M = M + X , the cost of the schedule can be bounded as

m′M ′ m′ |X| + M ′ + m′ − + 1 ≤ |X| + M ′ + m′ − + 1 h ( 2λ ) 1 ≤ |X| + M ′ + m′ 1 − + 1 ( ) 2λ 1 ≤ M 2 − + 1 , 2λ

which gives us the claimed approximation. ■

Using the schedule provided by Theorem 4.7 together with the compression tech- ⌈ ⌉ − 1 nique from Theorem 1.1, we get a 2 1/ε -batch schedule that is a (2 2λ + ε, 2)-

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 approximation for arboricity-λ graphs, for arbitrarily small ε ∈ (0, 1). This, however, is non-trivial only for ε < 1/2λ. Here we show, using a more direct approach, that approximation similar to Theorem 4.7 can be achieved with only 4 batches. Let G = (V,E) be a graph with two vertex covers α and β. Again, since we are dealing with only monotone schedules, we will focus on A = α \ β and B = β \ α. ⌊ ⌋ |A||B| ∩ 4-batch schedule. Let ξ = h+|A| . Let X = α β, A1 be the set of the ξ lowest degree (in G[A ∪ B]) vertices in A, and let B1 = NG(A1) ∩ B be the set of neighbors of

nodes in A1. The schedule consists of the following four vertex covers: V0 = X ∪A = α,

V1 = X ∪ A ∪ B1, V2 = X ∪ (A \ A1) ∪ B1, V3 = X ∪ (A \ A1) ∪ B, V4 = X ∪ B = β. Again, we first express the cost of this 4-batch schedule in terms of the edge density and other parameters of G[A∪B], then it will translate into an approximation in terms of arboricity. Lemma 4.8. Let G = (V,E) be a graph with two vertex covers α and β such that the graph induced by D = α ⊕ β has h > 0 edges. The cost of the 4-batch schedule is at | ∩ | | | | | − |A||B| \ \ most α β + A + B h+|A| + 1, where A = α β and B = β α. Proof. Since the schedule is monotone, and we never change the status of the nodes in X = α ∩ β, let us assume first that X = ∅. We analyze the cost of the schedule under this assumption, then add |X| to it, in the case when X is non-empty.

Now, the 4-batch schedule simplifies to: V0 = A, V1 = A ∪ B1, V2 = (A \ A1) ∪ B1,

V3 = (A \ A1) ∪ B, V4 = B, where A1 is the set of ξ lowest degree vertices in A and

B1 = N(A1)∩B. We will show that in order to get the claimed cost, we need to choose ξ as in the algorithm presented above.

The cost of the schedule is the maximum among the size of V1, which is of size |A| + |B |, and of V , which is of size |A| + |B| − ξ (note that V ⊆ V and thus not 1 3 ∑ 2 1 | | ≤ included). Note that B1 v∈A1 dG[D](v), so using Fact 4.5, we have: ∑ ∑ |B | ∈ d (v) ∈ d (v) h 1 ≤ v A1 G[D] ≤ v A G[D] = . |A1| |A1| |A| |A|

Thus, |B1| ≤ |A1|h/|A| = ξh/|A|, hence the cost of the schedule is at most the larger of |A| + ξh/|A| and |A| + |B| − ξ. Let us choose ξ so that those expressions are equal: | | − | | | || | | | | | | | − |A||B| B ξ = hξ/ A , so ξ = A B /(h + A ). This gives us cost A + B h+|A| . Recall, however, that ξ has to be an integer, so we round it down, i.e., we let ξ = ⌊| || | | | ⌋ | | | | − |A||B| A B /(h + A ) , which gives us cost A + B h+|A| + 1 (note that the expression |A| + ξh/|A| can only be improved by this rounding). To complete the proof, recall that in order to bound the cost of schedule in the case X ≠ ∅, we only need to add |X| to the cost above. ■

Theorem 1.4. Let G = (V,E) be a graph with two vertex covers α and β such that the graph induced by D = α⊕β has arboricity λ. The 4-batch schedule is a (2−1/(2λ+1), 1)- approximation.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Proof. The proof follows along the lines of the proof of Theorem 4.7, with the only |A||B| |A||B| difference that in Lemma 4.8, we have the term h+|A| instead of the h term of | | 1 Lemma 4.8. The additional A term is that gives rise to +1 in 2λ+1 term in the approximation. ■

How well can we schedule bounded degree/arboricity graphs? We prove below that for every d ≥ 4, there exist d-regular bipartite graphs G = (A ∪ B,E) of arbitrarily large size, such that any√ vertex cover reconfiguration schedule from A to B is no better than a (2 − Θ(1)/ d, 0)-approximation. It follows, in particular, that ≥ for every λ 4, there are graphs√ of arboricity at most λ where every reconfiguration schedule is at best a (2 − Θ(1)/ λ, 0)-approximation. This proves negative part of Theorem 1.3.

Theorem 4.9 (Arboricity Lower bound). For every 4 ≤ d < N/2, there is a bipartite ∪ | | | | ∈ d-regular graph G = (A B,E) with A = B = n [N,(2N], such that) any vertex cover reconfiguration schedule from A to B is no better than a 2 − √ 4 , 0 -approximation. d+1+1

We will use several known results on Ramanujan graphs. A d-regular bipartite graph G = (A∪B,E) is Ramanujan if the largest non-trivial eigenvalue of its adjacency matrix √ √ is in the interval [−2 d − 1, 2 d − 1] (such a matrix always has two trivial eigenvalues, d and −d).

Theorem 4.10 ([MSS15, Theorem 5.5]). For every d ≥ 3 and N > 2d, there exist d-regular bipartite Ramanujan graphs with n ∈ [N, 2N] nodes.

The incidence matrix M of a bipartite graph G = (A ∪ B,E) is a |A| × |B| binary matrix, where the (i, j) entry is 1 if and only if the ith vertex in A is adjacent to the

jth vertex in B. Let δ1 ≥ δ2 ≥ · · · ≥ δ|A| be the eigenvalues of the symmetric matrix MM T , where M T is the transpose of M.

Theorem 4.11 ([Tan84, Theorem 2.1]). Let G = (A ∪ B,E) be a d-regular bipartite

graph, such that δ1 > δ2. Then for every subset S ⊆ A of vertices, it holds that

d2|S| |N(S)| ≥ . |S| 2 − |A| (d δ2) + δ2

Note that the right hand side of the inequality can be transformed into the following form that is more convenient for us:  ( )  −1 |A| |S| d2 |N(S)| ≥ = |A| 1 − 1 + ·  . |A| · δ2 |A| δ2 1 + |S| d2

It is easy to verify that for every bipartite graph G with adjacency matrix X and incidence matrix M, every eigenvalue of MM T is also an eigenvalue of XXT , and hence is a square of an eigenvalue of X (compare [HL06, Theorem 4.15] with the theorem

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 above in this context). Also note that δ = d2 is an eigenvalue of MM T , corresponding to the all-ones eigenvector. Therefore, if the graph is 4 ≤ d-regular and Ramanujan, we 2 have that d = δ1 > 4(d − 1) ≥ δ2, and Theorem 4.11 applies, giving us the following.

Corollary 4.12. Let G = (A ∪ B,E) be a d-regular bipartite Ramanujan graph, for d ≥ 4. Then for every subset S ⊆ A of vertices it holds that  ( )  −1 |S| d2 |N(S)| ≥ |A| 1 − 1 + ·  . |A| 4(d − 1)

Proof of Theorem 4.9. Let G = (A ∪ B,E) be a d-regular bipartite Ramanujan graph with |A| = |B| = n provided by Theorem 4.10. Consider a reconfiguration schedule

S = V0,V1,...,Vℓ from A to B. Let Vi be the first vertex cover for which |A \ Vi| ≥ ηn,

where η ∈ (1/n, 1) is a parameter we will specify below. Let C = A \ Vi and note that

N(C) ⊆ Vi−1. Thus, using the definition of Vi, we have |Vi−1| ≥ |A| − |A \ Vi−1| + |N(C)| ≥ n − ηn + |N(C)|. From Corollary 4.12,we also have that  ( )  −1 ( ) ηd2 1 |N(C)| ≥ n · 1 − 1 +  ≥ n · 1 − , 4(d − 1) 1 + ηd/4

which implies that ( ) 1 |V − | ≥ n 2 − η − . i 1 1 + ηd/4

1 Optimizing for η, we see that the best choice is when η and 1+ηd/4 are balanced, that is, (d/4)η2 + η = 1. This means that denoting c = d/4, we obtain √ √ √ −1 + 4c + 1 (−1 + 4c + 1)(1 + 4c + 1) 2 2 η = = √ = √ = √ . 2c 2c(1 + 4c + 1) 4c + 1 + 1 d + 1 + 1

Thus, the claim follows as the cost of the schedule is at least ( ) 4 |Vi−1| ≥ n (2 − 2η) = n 2 − √ , d + 1 + 1

which completes the proof. ■

Proof of Theorem 1.3. The existence of a schedule is precisely Theorem 1.4, and the impossibility result is Theorem 4.9. ■

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 26

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 5

Distributed Computation of Schedules

In Section 5.1 we encapsulate our approach for the distributed computation of batched reconfiguration schedules for vertex cover by introducing our concept of a smallsepa- rator decomposition. Then, we show how to compute such a decomposition super-fast (i.e. O(log∗ n/ε) rounds) via a Cluster Merging algorithm. We show this for graphs for which G[α ⊕ β] is a cactus graph. Then, in Section 5.2, we turn to the degree-based schedules, which we previously discussed in Section 4.2, and show that such schedules can be computed super-fast on any graph. Afterwards, we show that with the same run-time, a shorter schedule with the same approximation factor can be computed on bounded arboricity graphs. Finally, we show a degree-based schedule with a much longer run-time, i.e., O(∆f(n)) where f(n) is the largest index of a node in an n-node graph, which can be computed in only a single round of communication.

5.1 Reconfiguration on Cactus Graphs

The main objective of this section is to show the following result.

Theorem 1.5 (Cactus Reconfiguration). For each ε > 0, there is a LOCAL algorithm that for any connected n-node graph G and vertex covers α and β such that G[α⊕β] is a cactus graph, computes a O(1/ε)-batch (1 + ε, 3)-approximation schedule in O(log∗n/ε) rounds.

To give better intuition for the property “G[α ⊕ β] is a cactus graph”, we observe that this property holds for several known graph classes.

Corollary 5.1. For any ε > 0 there exists a deterministic LOCAL algorithm with round complexity O(log∗n/ε) that for any connected n-node graph G = (V,E) with vertex covers α and β computes an O(1/ε)-batch (1+ε, 3)-approximation schedule, if G belongs to one of the following graph classes {cycles, trees, forests, chordal, cactus, even-hole-free, claw-free}.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Proof. To apply Theorem 1.5, it suffices to notice, as we did in Theorem 1.2, that for each of the graph classes above, G[α ⊕ β] is a cactus graph. ■

To efficiently compute a reconfiguration schedule in a distributed setting, wewant to deal with large parts of the graph at the same time, e.g., by decomposing the graph into independent/non-interfering clusters. To this end, we define the concept of small separator decompositions. These are sufficient to compute good reconfiguration schedules, both in terms of schedule length and approximation factor, as well as computation time. Afterwards, we show that such decompositions can be computed efficiently, i.e., in O(log∗n/ε) rounds, on several graph classes, such as cactus and even-hold-free graphs. In fact, it is sufficient if G[α ⊕ β] falls into the respective graph class.

5.1.1 Small Separator Decompositions

We first present the formal definition of a small separator decomposition andshowhow to use it to compute batch reconfiguration schedules. See Figure 5.1 for an illustration.

Figure 5.1: An example of a (d, x, k)-separator decomposition with d = x = 2 and k = 3 clusters (the right one is not connected). Every node is either clustered or is a separator and every edge not contained in a cluster has an endpoint which is either a separator (S-node) or a ghost node (Z-node).

Let U ⊆ V be a subset of the vertices of a given graph G = (V,E). The weak diameter of U is the maximum distance measured in G between any two vertices of U. The strong diameter (or simply diameter) is the diameter of the graph G[U], that is, it is the maximum distance between any two vertices of U measured in the graph G[U].

Definition 5.2 (Small Separator Decomposition). Let G = (V,E) be a graph with a

subset Z ⊆ V of ghost nodes. A collection of k clusters C1,...,Ck ⊆ V and a separator set S ⊆ V is a (weak) (d, x, k)-separator decomposition with regard to Z if the following hold:

1. partition: C1,...,Ck,S forms a partition of V ,

2. the weak diameter of each Ci (i.e. max{distG(u, v)|u, v ∈ Ci}) is upper bounded by d,

3. small separator set: |S| ≤ x,

4. S separates: There is no edge {u, v} ∈ E with u ∈ Ci \ Z, v ∈ Cj \ Z, and i ≠ j.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 When additionally G[Ci] has diameter at most d for all 1 ≤ i ≤ k we speak of a strong (d, x, k)-separator decomposition.

We note that in a simultaneous and independent work, a similar but different decomposition has been used to compute (1 + ε)-approximations of the minimum vertex cover problem in the CONGEST model, deterministically and in poly(ε−1, log n) rounds [FK20]. However, the computation presented in [FK20] has a run-time polynomial in log n, and so, it is not helpful for proving Theorem 1.5. Given a graph G and vertex covers α and β, we would like to compute a monotone schedule for each cluster independently. To do so without interference, the separator set S is needed. To save on the size of S, we observe that nodes in V \(α⊕β) never change, and so, can be ignored and are referred as ghost nodes. Next, we show that a small separator decomposition with few clusters is helpful to compute batch reconfiguration schedules.

Lemma 5.3. Let G = (V,E) be a graph with two vertex covers α and β and a (d, x, k)-

separator decomposition C1,...,Ck,S of G with ghost nodes Z ⊆ V \ (α ⊕ β). If each

G[Ci] admits a monotone ℓ-batch (η, c)-approximation schedule Si then G admits a (2ℓ + 2)-batch (η, x + k · c)-approximation schedule S.

Proof. Let Cα be the family of all the sets Ci for which |Ci ∩ α| > |Ci ∩ β| and let Cβ be

the family of the rest (for which |Ci ∩ α| ≤ |Ci ∩ β|). The schedule consists of 4 phases:

1. Add all nodes in S ∩ (β \ α) to the vertex cover.

2. Reconfigure all clusters in Cα in parallel, each Ci according to its given schedule

Si.

3. Reconfigure all clusters in Cβ in parallel, each Ci according to its given schedule

Si.

4. Remove all nodes in S ∩ (α \ β) from the vertex cover.

Schedule length. By definition, phases 1 and 4 take a single reconfiguration step each, and phases 2 and 3 take ℓ steps each. Therefore, the total length of the schedule is 2ℓ + 2. Validity. We first show that in each of the 2ℓ + 2 steps the nodes that change their status form an independent set. The first and fourth batches are independent sets as β \ α and α \ β are such, respectively. As phases 2 and 3 use monotone reconfiguration

schedules on the clusters in Cα and Cβ, no vertex in V \ (α ⊕ β) ever changes its status, in particular, no vertex in α ∩ β and no vertex in Z changes its status. As also vertices in S do not change their status in phases 2 and 3, the separation property of S ensures that there are no adjacent nodes in distinct clusters that change their status at the same time. Inside each cluster, the independence is inherited from the used valid schedules.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Next, we show that every edge is covered at all times. Any edge with both endpoints

in the same cluster Ci is covered at all times as this property is inherited from the used reconfiguration schedule for the cluster. Every edge with an endpoint in S is covered during phases 2 and 3 as S is part of the output after phase 1. Due to the separation property any edge with both of its endpoints in different clusters has one endpoint in Z ⊆ V \ (α ⊕ β), i.e., not both endpoints are in α ⊕ β. As any edge with the latter property has one endpoint in α ∩ β and all schedules are monotone the edge is covered at all times. After step 3 all nodes of β are in the cover, and as β is a vertex cover we can safely remove the nodes in phase 4 without destroying the covering property. Approximation. During phase 1, the size of the cover is at most x + |α|. For

estimating it in phases 2 and 3, let zα and zβ be the number of clusters in Cα and Cβ,

respectively; note that k = zα + zβ. Let ai = |α ∩ Ci|. We bound the size of the cover in phase 2:   ∑ ∑ ≥ ∑ ∑ η 1   |S| + zα · c + ηai + ai ≤ x + zα · c + ηai + ηai Ci∈Cα Ci∈Cβ Ci∈Cα Ci∈Cβ

≤ x + zα · c + η|α| ≤ η · max{|α|, |β|} + x + k · c.

Letting bi = |β ∩ Ci|, the size of the vertex cover during phase 3 is at most:   ∑ ∑ ≥ ∑ ∑ η 1   |S| + bi + zβ · c + ηbi ≤ x + zβ · c + ηbi + ηbi Ci∈Cα Ci∈Cβ Ci∈Cα Ci∈Cβ

≤ x + zβ · c + η|β| ≤ η · max{|α|, |β|} + x + k · c.

During phase 4, the size of the vertex cover only decreases, hence, it is also at most η · max{|α|, |β|} + x + k · c, which proves the claim. ■

In the proof of Lemma 5.3 we reconfigure clusters of the given small separator decomposition in a specific order. The next remark explains why a naïve usage ofsmall separator decompositions that does reconfigure all clusters at the same time canbe hurtful for the approximation guarantee.

Remark 5.4. Assume, for a given small separator decomposition, we can promise some good approximation on each cluster C ∈ C, e.g., a (η, c)-approximation. Note that the

approximation guarantee is only with respect to the maximum between Cα = C ∩ α

and Cβ = C ∩ β. Thus, simultaneously reconfiguring a cluster C with |Cα| ≫ |Cβ| and ′ | ′ | ≪ | ′ | a cluster C with Cα Cβ at the same time might result in a much worse overall approximation.

For illustration, consider a graph composed of the disjoint union of two stars S1

and S2 of the same size (i.e., K1,t for some integer t) with α set to be the center of S1

and the leafs of S2 and β defined as its complement. This graph immediately hasa

4-batch (1, 1)-approximation, which adds β ∩ S2, removes α ∩ S2, adds β ∩ S1 and then

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 removes α ∩ S1. On the other hand, see that a (1, 1)-approximation on S1 (resp. S2)

must add all of S1 (resp. S2) to the vertex cover before removing a single node from it. Therefore, applying the schedule of the stars simultaneously might result in a trivial (2, 0)-approximation algorithm.

Given a (d, x, k)-separator decomposition, all phases in the proof of Lemma 5.3 can be executed in O(d) rounds in the LOCAL model and we obtain the following theorem.

Theorem 5.5. If the conditions of Lemma 5.3 hold, then a (2ℓ + 2)-batch (η, x + k · c)- approximation schedule for G can be computed in O(d) rounds in the LOCAL model.

Proof. We show how to compute the required schedule given in Lemma 5.3. Consider its four phases. Phase 1 and 4 can each be implemented in a single round. To compute the schedule of each cluster (in phases 2 and 3), each node learns its entire cluster in O(d) rounds and locally computes its position in the schedule. ■

There are three parameters at play in the effect of a small separator decomposition on the computation of schedules: x, the separator set size, k, the number clusters, both affect the approximation factor of the schedule, and d, the cluster diameter, which affects the time it takes to compute one. In the next section, we show howtobalance those three parameters on a graph G for which G[α ⊕ β] is a cactus graph. In addition, recall that if G[α ⊕ β] is a cactus graph, our batch compression results from Theo- rem 1.2 imply the existence of good monotone schedules for any subgraph, as needed by Lemma 5.3 and Theorem 5.5.

5.1.2 Cluster Merging

In the following Lemma, we present our main tool for computing a small separator decomposition; we show that given a partition of the graph into connected clusters, we can quickly merge some clusters in the partition to ensure that each cluster either has diameter bounded from below or consists of a whole connected component of the graph. Its proof is inspired by the well-known GHS and GKP algorithms for the distributed computation of a minimum-weight spanning tree [GHS83, GKP98]. We use this subroutine in several parts of this thesis, in particular, we use it at the end of this section to transform a small separator decomposition of G[α ⊕ β] with potentially many distinct clusters into a small separator decomposition of all of G that only has few clusters (see Lemma 5.9), which is essential to keep the cost low when applying Lemma 5.3.

C { }k Definition 5.6 (d-diameter clustering). A d-diameter clustering = Ci i=1 of a ∪k graph G = (V,E) is a partitioning V = i=1Ci of the vertex set into k disjoint subsets, for a parameter k ≥ 1, such that for every 1 ≤ i ≤ k, G[Ci] is connected and has strong diameter at most d.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 We emphasize that the clusters in a d-diameter clustering need to be connected and that all vertices of the graph are contained in some cluster.

Lemma 5.7 (Cluster Merging). Let G = (V,E) be a graph with a d-diameter clustering ∗ C = (Ci)i∈k. For every ε ∈ (0, 1), there is an O(log n/ε + d)-round LOCAL algorithm that using C, computes a (O(1/ε) + d)-diameter clustering C′, where additionally, each cluster either has diameter at least 1/ε or consists of a whole connected component of G.

Proof. We describe the algorithm that merges clusters from C to obtain C′. To this end, C′ k C assume that initially, = (Ci)i=1 is identical to . For simplicity of exposition, we consider the cluster-graph G′ with the set C′ of vertices, where two clusters are adjacent if any of their corresponding vertices are adjacent in G. We describe the algorithm using G′, and explain below how this can be implemented in G. The algorithm consists of two stages, the first consists of O(log(1/ε)) iterations, while the second happens only once.

⌈ ⌉ Stage 1. This stage consists of iterations t = 0, 1, 2,..., log2(1/ε) . Next, we describe an iteration t. A cluster Ci is small (in iteration t) if it has diameter at most 2t and otherwise it is large. A small cluster is isolated if it is not adjacent to any other small cluster (it could still have edges to large clusters). We update the clustering C′ by merging several small clusters together. To this end, ′ ′ { } ∈ every small cluster Ci (thought of as a node in G ) picks an arbitrary edge v, u ′ ′ E(G ) connecting it to another small cluster Cj, if such an edge exists. Let F be the { ′ ′ } set of selected edges. The edges in F are oriented as follows: if an edge Ci,Cj was ′ ′ ′ ′ picked only by Ci, it becomes an out-edge of Ci, i.e., oriented as (Ci,Cj), otherwise (if ′ ′ { ′ ′ } Ci and Cj both picked Ci,Cj ) it is oriented arbitrarily. This gives us a pseudoforest F⃗ (in G′), i.e., a directed subgraph with maximum outdegree 1. We compute a maximal independent set I in F⃗ with the algorithm from [CV86]. We update the clustering C′, as follows: every non-isolated small cluster that is not in I picks an arbitrary adjacent cluster in I and merges with it. That is, given a cluster C′ ∈ I, let C′ ,...,C′ be the clusters that merge with C′. We remove C′ and i i1 il i i C′ ,...,C′ from from C′ and add a new cluster C′ = C′ ∪C′ ∪· · ·∪C′ . This completes i1 il i i1 il the description of one iteration of Stage 1.

Stage 2. Every cluster with diameter smaller than 1/ε picks an arbitrary adjacent cluster, if there is any, and merges with it.

This completes the description of the algorithm.

Diameter bounds. Towards the rest of the analysis, let us first note that after each iteration t of Stage 1, due to the maximality of the independent set I, if a small

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 cluster was not merged, then all of its neighbors in G′ must have diameter greater than 2t. Therefore, after the last iteration (t = ⌈log(1/ε)⌉) of Stage 1, every cluster with diameter smaller than 1/ε (i.e., a small cluster) that is not a whole connected component of G, is adjacent to a cluster of diameter at least 1/ε, and hence is merged with such a cluster in Stage 2. Thus, after Stage 2, every cluster is either an entire connected component of G or has diameter at least 1/ε. Next, let us see that the diameter of a cluster does not increase abruptly within a single step of the algorithm. In iteration t of Stage 1, only clusters with diameter at most 2t participate in a merge, and whenever a cluster merges with a set of other clusters they together induce a subgraph of G′ of diameter at most 2 (which implies that the longest chain of such clusters is of length 3). Thus, after iteration t, every new cluster has diameter at most 3·2t +2, that is, 2t for every cluster in any chain of merged clusters and the additive 2 for the edges connecting the clusters in the chain. Therefore, after Stage 1, every cluster has diameter at most max{d, 3 ·⌈1/ε⌉ + 2} = d + O(1/ε). In Stage 2, every cluster of diameter smaller than 1/ε that is not a separate component of G merges into another cluster, hence, after this stage, the maximum diameter of a cluster is increased by at most 2 + 2/ε. This yields that the maximum diameter of a cluster is still at most d + O(1/ε).

Runtime and implementation in G. First, we can use a preprocessing stage (before Stage 1) of O(d) rounds, to let each cluster elect a leader and compute its diameter. Note that in iteration t of Stage 1, all clusters that participated have diameter bounded by 2t and thus one round of an algorithm on the cluster-graph in iteration t can be simulated in O(2t) rounds in G. Computing a maximal independent with the algorithm from [CV86] uses O(log∗η) cluster-graph rounds where η is the maximum

ID of a node in F⃗ (here, η = poly(|V |), as each Ci can assume the ID of its leader). Therefore, the first stage has runtime

⌈log(1/ε)⌉ ( ) ∑ log∗n O(log∗n · 2t) = O . ε t=1

Similarly, Stage 2, takes O(1/ε) rounds in G. ■

The value of ε in Lemma 5.7 can either be a constant or chosen subconstant and can depend on n without violating the correctness of the claim. Next, we show that any small separator decomposition of G[α ⊕ β] can be transferred into a small separator decomposition of G with few clusters (O(εM) with M = max{|α|, |β|}), where the ghost node set can be chosen in order to apply Theorem 5.5. We begin with a simple observation about vertex covers.

Observation 5.8. Any vertex cover of a connected graph with diameter ≥ d has size ≥ ⌈d/2⌉.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Proof. Due to the lower bound on the diameter there is a path v0, . . . , vd of length d { } ⌊ d−1 ⌋ with d + 1 vertices and d edges. The edges v2i, v2i+1 , i = 0,..., 2 have distinct endpoints and any vertex cover needs to contain (at least) one endpoint of each such ⌊ d−1 ⌋ ⌈ ⌉ ■ edge. As the number of edges is 2 + 1 = d/2 the claim follows. Next, we use Lemma 5.7 to reduce the number of clusters in a small separator decomposition without increasing the number of separators and with only mildly increasing the cluster diameter. Lemma 5.9. For any ε > 0, d ≥ 1 there is a deterministic LOCAL algorithm that, given a graph G = (V,E) with two vertex covers α and β and a (d, x, k)-separator decomposition of G[α ⊕ β] with an empty ghost node set, computes a (d + O(1/ε), x, k′)-separator decomposition of G with a ghost node set Z = V \ (α ⊕ β) and k′ = max{1, 2εM} clusters in O(log∗n/ε + d) rounds. We emphasize that Lemma 5.9 can deal with disconnected input clusters as long as their weak diameter is small which is along the definition of a (d, x, k)-separator decomposition. As such, the output clusters of Lemma 5.9 are not necessarily connected (i.e. each cluster might be formed of several disconnected components).

Proof. Let D = α ⊕ β, X = α ∩ β and let C = {C1,...,Cl} be the (d, x, k)-separator decomposition of G[D] with separator set S ⊆ D where each connected component of a cluster of the input separator decomposition is its own cluster. Note that D∪X = α∪β. We say that C is the first clustering. The second clustering is formed by the clusters in C and a new cluster for every

vertex that is not contained in C1 ∪ ... ∪ Cl. Each such new cluster consists of a single node. We obtain a d-diameter clustering of G (with the same d as in the first clustering).

Third clustering. Apply Lemma 5.7 to the second clustering and obtain a (d + O(1/ε))-diameter clustering C′ of G. If C′ consists of a single component, then clearly the number of components is at most max{1, 2εM}. Otherwise, C′ consists of at least 2 components, and by Lemma 5.7, since G is connected, each cluster has minimum diameter 1/ε. By Observation 5.8, the diameter 1/ε implies that every vertex cover of ′ G must have at least 1/2ε nodes in Ci and so, we conclude that there are at most 2εM clusters.

Fourth clustering. Now, notice that each cluster C′ consists of S-nodes, clusters

Ci (from the clustering C), and Z-nodes, where we defined Z = V \ D. We remove from each C′ its S-nodes, and claim that this yields a (d + O(1/ε), x, k′)-separator decomposition with a ghost node set Z and at most k′ = ⌈2εM⌉ clusters: 1. Before removing the S-nodes, each cluster C′ had a strong diameter of O(1/ε). After the removal, it might become disconnected, but must still have a weak diameter of O(1/ε).

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 2. By the definition of S (in the first clustering), we have |S| ≤ x.

3. From the definition of a d-diameter clustering, before removing the S-nodes, C′ was a partition of V . Hence, S together with the new clusters again form a partition of V .

4. S separates: Note that every component Ci of C is contained in a distinct cluster ′ ′ ′ ′ C of C , and for every C , C \Z is composed only of such Ci components. There-

fore, together with the fact that S separates {Ci}i, this shows that S separates { ′ \ } ■ Cj Z j.

5.1.3 Computing Small Separator Decompositions on Cactus Graphs

To prove Theorem 1.5, we show how to compute a small separator decomposition with parameters d = O(1/ε), x = ε|α⊕β| and k = max{1, 2εM} (where M = max{α, β}) on graphs G for which G[α ⊕ β] is a cactus graph. We stress that the usual approaches for computing (small diameter) decompositions, such as [AGLP89, LS93, RG20, GKM17b], neither include any vertex-separators nor give any promise on the number of clusters. Another downside is that those techniques inherently require Ω(log n) rounds and thus are not useful for computing a small separator decomposition super-fast, and so, will not help us prove Theorem 1.5. Therefore, new methods for computing our decomposition are needed to prove the following result.

Lemma 5.10 (Cactus-Core Decomposition). For all ε > 0 there exists a LOCAL algorithm that for any connected n-node graph G = (V,E) and vertex covers α, β such that G[α⊕β] is a cactus graph computes a (d, x, k)-separator decomposition with d = O(1/ε), x = ε|α⊕β|, a ghost node set Z = V \(α⊕β) and k = max{1, 2εM} (M = max{|α|, |β|}) clusters in O(log∗n/ε) rounds.

We begin with the following observation on cactus graphs that is crucial for bounding the number of separators in our algorithm. Recall that a graph H is a minor of a graph G if H can be obtained from G by removing edges, vertices, or contracting edges (merging their endpoints).

Observation 5.11 (Cactus graphs). 1. The family of cactus graphs is closed under taking minors. 2. Every connected cactus graph on n vertices contains at most 3n/2 edges.

Proof. For the first claim, observe that if after removing vertices or edges, or contracting edges, an edge belongs to at least two cycles (i.e., the obtained graph is not cactus), then it will belong to at least two cycles after reverting the above operations too. To bound the number of edges, observe that all cactus graphs are simple, and since each edge belongs to at most 1 cycle, one can remove an edge from each cycle to obtain a tree, hence the number of edges is m = n − 1 + c, where c is the number of cycles.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Also, each cycle contains at least 3 edges, and every edge belongs to at most one cycle, hence, c ≤ m/3. Thus, m − n + 1 ≤ m/3, which implies that m < 3n/2. ■

In the proof of the following statement we use the cluster merging procedures devel- oped in Subsection 5.1.2 to compute a decomposition of the graph with small diameter clusters; then we add one vertex of each inter-cluster edge to the separator set and Observation 5.11 is crucial to show that the separator set is small.

Lemma 5.12 (Small separator set, many clusters). For any ε > 0 and for any n-node connected cactus graph G = (V,E) with a ghost set Z = ∅, there exists a (d, x, k)- separator decomposition with d = O(1/ε) and x = k = εn, and with the additional property that the strong diameter of each cluster of the decomposition is at most d. Furthermore, such a decomposition can be found in O(log∗n/ε) rounds in LOCAL.

Proof. Apply Lemma 5.7 on the 0-diameter initial clustering of G, with every cluster ∈ C′ { ′ ′ consisting of a single node v V . This yields a clustering = C1,...,Ck} with each cluster having a strong diameter O(1/ε), in O(log∗n/ε) rounds. If k = 1, we let S = ∅ to get the desired decomposition. On the other hand, if k ≥ 2, recall that Lemma 5.7 gives in this case clusters of diameter at least 1/ε (as G is connected), and so, the total number of clusters is bounded by k ≤ εn. It follows from the definition of a d-diameter clustering and the assumption that G is connected that each cluster induces a connected subgraph of G. Let us now bound the number of inter-cluster edges I (i.e., edges with endpoints in different clusters) for k ≥ 2. First, observe that there can be at most 2 inter-cluster edges connecting any two given clusters, since otherwise, using the fact that each cluster induces a connected subgraph, we can find two cycles that share an edge, which contradicts the assumption that G is a cactus graph. Let us form the cluster-graph H = (C′,E′), where two vertices ′ ′ ∈ C′ ′ Ci,Cj are adjacent iff there is an inter-cluster edge in G with one endpoint in Ci ′ ′ and the other in Cj. The observation above implies that an edge in E can correspond to at most 2 inter-cluster edges, i.e., |E′| ≥ |I|/2. On the other hand, since each cluster ′ Ci induces a connected subgraph of G, observe that H is a simple minor of G. Recall from Observation 5.11 that cactus graphs are closed under taking minors, hence H is a cactus graph, which implies by Observation 5.11 that the number of its edges can be bounded by:

3 3 |C′| − 1 + |M(H)| ≤ |C′| = k, 2 2

where M(H) is a maximum matching of H. Putting all together, thus the number of inter-cluster edges is at most |I| ≤ 2|E′| ≤ 3k. To construct S, for each inter-cluster edge, arbitrarily add one of its two endpoints to S and remove that node from its cluster, while the other endpoint remains in its cluster. These removals might disconnect clusters in C′, creating a new clustering C with

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 (possibly) more clusters; however, this process does not introduce new edges between clusters. Thus S separates the clusters C and we get that |S| is exactly the number of inter-cluster edges, hence, at most 3k ≤ 3εn. The clusters of C along with S provide the desired decomposition. Since ε was arbitrary, we get the claim of the lemma. ■

To obtain Lemma 5.10 from the small separator decomposition provided by Lemma 5.12 we use Lemma 5.9 to reduce the number of clusters. Proof of Lemma 5.10. Let D = α ⊕ β. By our assumption, G[D] is a cactus graph

with components G1,...,Gk. In short, to compute the desired decomposition, we begin with the trivial decomposition in which each node of G forms its own 0-diameter cluster and the trivial (but large) separator set S = D; the number of clusters can be upper bounded by n. The size of the separator set of this decomposition is bounded by |D| (recall that nodes in Z = V \ D are not counted as separators) Then, in two steps, we first merge the clusters of G[D] via Lemma 5.7 in order to reduce the number of separating nodes, and then we merge all clusters of G via Lemma 5.7 in order to reduce the number of clusters. We detail on the crucial ingredients for the whole process.

(d, x, k)-separator decomposition C1 with d = 0 and x = |D|, k = n: Each node v of G forms its own 0-diameter cluster {v} and we use a separator set S = D.

(d, x, k)-separator decomposition C2 with d = O(1/ε) and x = ε|D|, k = n:

We consider the induced graph G[D] with connected components G1,...,Gk and apply

the cactus graph decomposition in Lemma 5.12 to each component Gi to obtain a clustering {C } and a separator set S , for each such G . We use those to form ij j=1,...,ki i ∪ i C { } k a clustering = Cij j=1,...,ki,i=1...k and a separator set S = i=1 Si of G[D]. Note that by Lemma 5.12, each C is a connected cactus graph with diameter O(1/ε) and the size ∑ ij k | | | | ′ of S is bounded by i=1 ε Gi = ε D . The obtained clustering is a (d, x, k )-separator decomposition of G[D] with an empty ghost node set, separator set S, and parameters d = O(1/ε), x = ε|D| and k′ = |D| (as there might be many connected components in

G[D]). Along with the 0-diameter clustering of G[V \ D] (i.e. C1 on G[V \ D]), we get

C2.

(d, x, k)-separator decomposition C3 with d = O(1/ε) and x = ε|D|, k = 2εM: We merge clusters using Lemma 5.9 to obtain a (d, x, k)-separator decomposition C′ = { ′ ′ } C1,...,Ck with a small number of clusters, while increasing the diameter of each cluster by at most O(1/ε). By Lemma 5.9, C′ has a ghost node set Z = V \ (α ⊕ β), separator set S and parameters d = O(1/ε), x = ε|D| and k = max{1, 2εM} (recall that M = max{|α|, |β|}).

Runtime. For the runtime, see that applying Lemma 5.12 to each component takes O(log∗n/ε) rounds and Lemma 5.9 takes O(log∗n/ε + d) = O(log∗n/ε) rounds. Thus, the algorithm consists of O(log∗n/ε) rounds in total. ■

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 We are now ready to prove Theorem 1.5.

Proof of Theorem 1.5. Let D = α ⊕ β. By our assumption, G[D] is a cactus graph.

Use Lemma 5.10 to compute a (d, x, k)-separator decomposition C = {C1,...,Ck} of G with ghost node set Z = V \ (α ⊕ β), separator set S and parameters d = O(1/ε), x = ε|D| and k = max{1, 2εM} (recall that M = max{|α|, |β|}). Now, apply Theorem 5.5 to the clustering C to compute a reconfiguration schedule: For each cluster C ∈ C, G[D ∩ C] is a cactus graph, hence, from Theorem 1.2, G[C ∩ D] (and thus also G[C]) has a O(1/ε)-batch (1 + ε, 3)-approximation schedule. Thus, we can apply Theorem 5.5 on the clustering C and obtain a O(1/ε)-batch (1+ε, ε|D|+k·3)- approximation schedule, that is, in total we can upper bound the size by

|D|≤2M (1 + ε)M + ε|D| + k · 3 ≤ (1 + ε)M + ε · 2M + max{1, 2εM}· 3 ≤ (1 + 9ε)M + 3,

showing that the schedule is a (1 + 9ε, 3)-approximation. Rescaling ε provides the result. For the runtime, see that applying Lemma 5.10 takes O(log∗n/ε) rounds. The- orem 5.5 takes O(d) = O(1/ε) rounds. Thus, the algorithm consists of O(log∗n/ε) rounds in total. ■

Due to Observation 4.2, Theorem 1.5 can be applied if G belongs to one of various graph classes.

5.2 Distributed Computation of Degree-Based Schedules

In this section we give the following results for the distributed computation of reconfiguration schedules for computing degree-based schedules (Section 4.2) on graphs with bounded arboricity.

Theorem 1.6. Let G be a graph with vertex covers α and β, such that G[α ⊕ β] has arboricity at most λ, with λ known to all nodes. For every ε > 0, there exists a ( ) O(log∗ n/ε)-round LOCAL algorithm that computes a O λ/ε2 -batch (2 − 1/2λ + ε, 1)- approximation schedule from α to β.

Note that even though the assumption on the knowledge of the arboricity is some- what unusual, the nodes might be able to get it indirectly in some cases, for example, if they know that the graph is planar, they also know that the arboricity is bounded by 3. In fact, since we are only interested in the arboricity of the bipartite graph G[α ⊕ β],

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 they know that λ ≤ 2 as triangle free planar graphs have at most 2n − 3 edges. We obtain the following corollary.

Corollary 5.13 (Planar Graphs). Let G = (V,E) be a planar graph with two vertex covers α and β. There is a O(log∗ n/ε)-round LOCAL algorithm that computes a 2 − 1 O(1/ε )-batch reconfiguration schedule from α to β that is a (2 5 +ε, 1)-approximation.

In order to prove Theorem 1.6, we first present a simple algorithm that yields an O(∆/ε)-batch schedule (Subsection 5.2.1). Then, in Subsection 5.2.2 we show how the bounded arboricity case can be reduced to a bounded degree case and obtain a schedule of length O(λ/ε2). Finally, in Subsection 5.2.3 we show that there exists an algorithm for computing degree-based schedules much faster (i.e. in a single round), but with a much worse length.

Theorem 1.7. Let G = (V,E) be an n-node graph with arboricity λ and two vertex covers α and β. There exists a 1-round LOCAL algorithm that computes an O(∆f(n))-batch (2 − 1/2λ, 1)-approximation schedule from α to β, when f(n) is the largest identifier among the nodes in the graph and is known to all nodes.

In all parts, G = (V,E) is the input graph and α and β are the two input vertex covers. Let A = α \ β, by B = β \ α and by M = max{|α|, |β|}.

5.2.1 An O(∆/ε)-Batch Schedule

In this section, we assume the graph G is arbitrary (i.e., no knowledge of λ).

We call a partition of the vertices in A into clusters E1,..., Eℓ degree ordered if

• for every two nodes vi ∈ Ei, vj ∈ Ej with i < j, deg(vi) ≤ deg(vj), where deg refers to the degree in the induced subgraph G[α ⊕ β], and

• |Ei| = O(εM) where M = max{|α|, |β|} and ε is some small (tunable) parameter.

Note that the partition is defined for given parameters ℓ, ε, and vertex covers α and β. We associate the following schedule with a given degree ordered partition.

O(ℓ)-batch schedule (for a given degree ordered partition). At step 2i,

add N(Ei) ∩ B to the vertex cover. At step 2i + 1, remove Ei from the vertex cover. In Lemma 5.14 we bound the length and the cost of the schedule. Later, in Lemma 5.15 we show how to compute the needed partition with an adequate choice

of parameters (ℓ and ε). Iterating through the Ei’s and reconfiguring them sequen-

tially, with an arbitrary order inside each Ei, yields the same schedule as described in Section 4.2, which is the main ingredient for the next lemma.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Lemma 5.14 (Schedule Cost). Let ε ∈ (0, 1), η ≥ 1, c ≥ 0 and let G = (V,E) be a graph with two vertex covers α and β for which the sequential degree-based schedule yields a (η, c)-approximation, regardless of the order of vertices inside a degree class. Then any schedule associated with a degree ordered partition into ℓ clusters and parameter ε is an O(ℓ)-batch (η + ε, c)-approximation schedule.

Proof. Let S be the batch schedule associated with the given partition E1,..., Eℓ. Sched- ule S has length O(ℓ) and is valid as A = α \ β and B = β \ α are independent sets, and a node is only removed from the cover after all of its neighbors have been added (so all edges are always covered). To bound the cost of S, let S′ be an arbitrary sequential execution of S, i.e, the

reconfiguration step ‘Remove Ei’ is replaced with |Ei| single steps in which the vertices

in Ei are removed in an arbitrary order, and ‘Add N(Ei)∩B’ is replaced with |N(Ei)∩B| single steps, accordingly. By the assumption in the lemma S′ is an (η, c)-approximation.

Let 1 ≤ s ≤ ℓ and let Ws be the vertex cover right before removing Es in S. Observe that ∪∆t E ∪ ∪s E ∩ Ws = r=s r (N( r=1 r) B) . ′ S′ Next, consider the vertex cover Ws obtained in the degree-based schedule , just after removing the last vertex of Es. We have

′ ∪∆t E ∪ ∪s E ∩ Ws = r=s+1 r (N( r=1 r) B) .

S′ | ′| ≤ Schedule achieves cost at most ηM + c. Thus, Ws ηM + c. We bound the size of Ws by

(∗) | | | ′| | \ ′| | ′| |E | ≤ Ws = Ws + Ws Ws = Ws + s (η + O(ε))M + c.

where we used |Ei| = O(εM) (by the definition of the partition) at (∗). Rescaling ε implies the claimed bound on the cost of our schedule. ■

Now, we show how to compute a suitable degree ordered partition of A.

Lemma 5.15 (Degree-Based Clustering). Let ε ∈ (0, 1) and let G = (V,E) be a graph with two vertex covers α and β. There exists a LOCAL algorithm that finds a degree ∗ ordered partition E1,..., Eℓ of A with parameter ε and length ℓ = O(∆/ε) in O(log n/ε) rounds.

Proof. For 1 ≤ i ≤ ∆, let U be the set of degree-i vertices of A (in G[A ∪ B]). Note ∪ i ∆ that A = i=1 Ui. Starting with the trivial clustering of G in which each vertex forms a singleton cluster, apply the algorithm from Lemma 5.7 with parameter ε to compute a clustering C. The clustering consists of at most ⌈2εM⌉ clusters, since if there is more then one cluster, every cluster has diameter at least 1/ε, and by Observation 5.8 contains at least 1/2ε nodes from any vertex cover of G.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Within each cluster C ∈ C, we compute the following partition of C ∩ A. For each 1 ≤ i ≤ ∆, partition U ∩ C into exactly t = ⌈1/ε⌉ subsets AC ,AC ,...,AC , each of size i i1 i2∪ it ⌈ | ∩ |⌉ C at most ε Ui C (some of them might be empty). Let Ai,j = C∈C Ai,j, we obtain ∑ ∑ | | | C | ≤ | ∩ | | | |C| Ai,j = Ai,j ε Ui C + 1 = ε Ui + = O(εM). C∈C C∈C

Where the last equality follows from the facts that Ui ⊆ A and |C| = O(εM).

We obtain the desired partition by ordering the sets Ai,j lexicographically A1,1,A1,2,

...,A1,t,A2,1,A2,2,..., formally, we set Ek = Ai,j for k = i · t + j for k = 1,..., ∆ · t. The length of the partition is ℓ = ∆ · t = O(∆/ε). The runtime bound follows, as applying Lemma 5.7 takes O(log∗n/ε) rounds, and for each node to know its corresponding i, j (and to decide on the index in the partition), it just needs to learn its cluster C, which is done in additional O(1/ε) rounds. ■

We summarize the results of this section in the following theorem.

Theorem 5.16. Let G = (V,E) be an n-node graph with two vertex covers α and β, for which the sequential degree-based schedule is an (η, c)-approximation. For every ε > 0, there exists a O(log∗ n/ε)-round LOCAL algorithm that computes a O (∆/ε)-batch (η + ε, c)-approximation schedule from α to β.

Proof. Applying the described schedule with an appropriate scaling of ε, along with Lemma 5.14 and Lemma 5.15 yields the desired result. ■

Applying Theorem 5.16 to graphs of bounded arboricity λ, together with the sequential (2 − 1/2λ, 1)-approximation schedule from Theorem 4.7 yields the following result.

Corollary 5.17. Let G = (V,E) be a graph with arboricity λ and two vertex covers α and β. For every ε > 0, assuming that nodes know the maximum degree ∆ in ⊕ ∗ G[α (β], there exists) a O(log n/ε)-round LOCAL algorithm that computes a O(∆/ε)- − 1 batch 2 2λ + ε, 1 -approximation schedule from α to β.

5.2.2 From Bounded Degree to Bounded Arboricity: an O(λ/ε2)-Batch Schedule

Corollary 5.17 gives a (2 − 1/(2λ) + ε, 1)-approximation schedule of length O(∆/ε) on graphs with arboricity λ. However, graphs of very low arboricity (such as planar graphs) might have a very large maximum degree, making the schedule inefficient in terms of schedule length. We will now describe a batch schedule for graphs of bounded arboricity which uses the results of the previous section as a subroutine. It requires global knowledge of λ and ε. We use the notation η = ⌈2λ/ε⌉ to describe the schedule.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 2 O(λ/ε )-batch schedule. In the first batch, add all vertices in Bη = {v ∈ B : |N(v) ∩ A| ≤ η} to the vertex cover. Then apply the algorithm from Theorem 5.16 ′ ′ ′ with ∆ = η and ε = ε/2 to compute a schedule from B = B \ Bη to A = A \{v ∈ A :

N(v) ∩ B ⊆ Bη}. Reverse the obtained schedule via Observation 3.2, to complete the A − to − B schedule. We will use the following result to bound the cost of the schedule in the proceeding theorem.

Lemma 5.18 ([Sol18, Lemma 8]). Let W be a vertex cover in a graph G = (V,E)

of arboricity λ, and H = {v ∈ V : dG(v) ≥ λ/τ}, for a given τ ∈ (0, 1). Then |H \ W | ≤ ε|W |.

Proof of Theorem 1.6. The validity of the schedule follows from the validity of the B′ − to − A′ schedule and Observation 3.2. Thus, from Theorem 5.16, the runtime of the algorithm is O(log∗ n/ε) (note that reverting the schedule can be done by each node locally as the O(η/ε) global upper bound on the length of the schedule is globally known). We apply Lemma 5.18 with the vertex cover A′ in the graph G[A′ ∪ B′]

and τ = λ/η, to see that |Bη| ≤ (λ/η)|A|. Thus, the first batch only contributes 1 to the length of the schedule and a λ|A|/η term to the cost. By Theorem 5.16 and Theorem 4.7, the A′ − to − B′ schedule we computed is a O(η/ε) = O(λ/ε2)-batch schedule and has cost at most (2 − 1/2λ + ε/2)M + 1, where M = max{|α|, |β|}. Thus, the overall cost is (2−1/2λ+ε/2+λ/η)M +1, which gives the promised approximation, by the choice of η. ■

5.2.3 Computing a Schedule in a Single Round

Denote by f(n) the largest identifier of a node in a given n-node input graph. In the following section, we show that the degree based schedule described in Section 4.2 can be computed super-fast, i.e. 1 round, but with an increased schedule length of O(∆f(n)). First, we show that there always exists a degree ordered partition which can be computed without any communication.

Lemma 5.19. Let G = (V,E) be a graph with two vertex covers α and β. There

exists a degree ordered partition E1,..., Eℓ with ℓ = ∆f(n) (f(n) is the largest identifier

among the nodes in the graph) where |Ei| ≤ 1 for all i = 1, . . . , ℓ. Furthermore, this partition can be computed without any communication in the LOCAL model.

Proof. The main idea of the partition is to utilize the ID space to give a partition of the nodes which can be computed without any communication, with the cost of having

many empty sets in it. Given i ∈ [∆] and j ∈ [f(n)], we define Ai,j as follows:   {v}, if degD(v) = i and id(v) = j Ai,j =  ∅, otherwise

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Where degD(v) is the degree of v in the induced graph G[D] (D = α ⊕ β). Note that

each v appears in a exactly one Ai,j and that each Ai,j contains at most one node.

We obtain the desired partition by ordering the sets Ai,j lexicographically A1,1,A1,2,

...,A1,f(n),A2,1,A2,2,..., formally, we set Ek = Ai,j for k = (i − 1)f(n) + j for k = 1,..., ∆f(n). The length of the partition is ℓ = ∆f(n). For the computation of the partition, every node in A knows its degree and ID and

so, can compute without any communication the Ai,j it belongs to. ■

To compute a schedule using a degree ordered partition, every node in B needs to know when will its neighbors leave the cover.

Theorem 5.20. Let G = (V,E) be an n-node graph with two vertex covers α and β, for which the sequential degree-based schedule is an (η, c)-approximation. There exists a 1-round LOCAL algorithm that computes an O(∆f(n))-batch (η, c)-approximation schedule from α to β, when f(n) is the largest identifier among the nodes in the graph.

Proof. See that Lemma 5.19 gives a degree ordered partition {Ei}i∈[ℓ] with ℓ = ∆f(n) clusters and at most 1 node in each Ei and let S be the schedule associated with it. Recall the degree based schedule from Section 4.2:

Degree Based Schedule: Iterate over the vertices in A in an increasing order v1, v2,... of their degree in G[A ∪ B] (breaking ties arbitrarily), for each vertex, adds all its neighbors to the vertex cover, if they are not already in the cover, and then remove it from the current cover.

Note that as each Ei contains at most 1 vertex, the schedule S associated with

{Ei}i∈[ℓ] is exactly the Degree Based Schedule described above (with many redundant steps where nothing is done). Therefore, S and the degree based schedule must have the same approximation. For the computation of this schedule, every node v in A sends a message (i, j) such

that v ∈ Ai,j, which is the only information needed by nodes in B to compute their position in the schedule associated with the degree base partition. ■

We are now ready to prove Theorem 1.7.

Proof of Theorem 1.7. To prove( Theorem) 1.7, simply note that by Theorem 4.7, the − 1 degree based schedule is a 2 2λ , 1 -approximation schedule. Therefore, by Theo- rem( 5.20,) there exists a 1-round LOCAL algorithm for computing an O(∆f(n))-batch − 1 ■ 2 2λ , 1 -approximation schedules.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 44

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 6

Hardness of Schedule Computation

First, in Section 6.1, we present a gap between the existence of reconfiguration schedules of weighted vertex covers and their computation. That is, we show that there exists a family of weighted cycles on which there always exists a (1+ε)-approximation schedule, but computing it takes Ω(n) rounds. Then, in Section 6.2 we lift the lower bound to the unweighted case. Finally, in Section 6.3, we turn our focus to unweighted cycles, and show that computing a (2 − ε)-approximation schedule with O(1) batches requires Ω(log∗n) rounds.

6.1 An Ω(n) Lower Bound for Weighted Cycles

In the (minimum) weighted vertex cover problem each vertex v is assigned a weight w(v) ∈ N and the objective is to find a vertex cover S of minimum total weight ∑ v∈S w(v). The weighted vertex cover reconfiguration problem is a natural general- ization of the unweighted vertex reconfiguration problem, that is, the only change is that the cost of a schedule is determined by the total weight of the (intermediate) vertex covers. It is known that there are graph families on which even (2 − ε)-approximation schedules do not exist for any constant ε > 0, e.g., complete bipartite graphs. In this section, we show that there are graphs on which (1 + ε)-approximation schedule exists and can also be computed efficiently in a centralized model, but computing such schedules in the LOCAL model takes Ω(n) rounds. Let c ≥ 1 be a constant integer and t : N → N be a function such that t(n) = o(n).

Next, we define a graph family Gt,c = {Gn,t,c | n ∈ N}. When t and c are clear from context, they are omitted.

n Graph Gn,t,c. Let Gn,t,c = (V, E, w) be an n-node cycle consisting of k := 4t(n)+2 identical segments, I1,...,Ik, with each Ii defined in the following way: i − i − i − i • Ii has 4t(n)+2 nodes v1 v2 . . . v4t(n)+1 v4t(n)+2.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 i i · • heavy nodes: w(v2t(n)+1) = w(v2t(n)+2) = c t(n).

i i i i • light nodes: w(v1) = ... = w(v2t(n)) = w(v2t(n)+3) = ... = w(v2t(n)+4) = 1. i i+1 − To complete the definition we add the edges (v4t(n)+2, v1 ) for all i = 1, . . . , k 1 and k 1 (v4t(n)+2, v1).

Properties of Gn,t,c. Note that this graph has two optimal vertex covers:

∪k ∪k { i | } { i | } Vodd := vj j is odd , and Veven := vj j is even . i=1 i=1

Note that when restricted to any single segment Ii , both Vodd and Veven have exactly

1 heavy node and t(n) light nodes, hence, w(Vodd ∩ Ii) = w(Veven ∩ Ii) = (c + 2)t(n),

therefore, it also holds that w(Vodd) = w(Veven) = k(c + 2)t(n) = Θ(n).

Lemma 6.1. Let c ∈ N and t(n) = o(n). For every G = Gn,t,c ∈ G and every pair α, β of vertex( covers) of G, there exists a monotone (1,O(t(n)))-approximation schedule of n length O t(n) between α and β.

Proof. Let C1,...,Cr be the set of connected components in G[α⊕β]. First, we reduce the case r = 1 to the case r > 1, and then prove the lemma for the latter. If r = 1,

add two weight 1 β-nodes, b1 and b2, to α and consider the following reasoning given a

schedule from α ∪ {b1, b2} to β: if S is an (η, c)-approximation schedule, one can obtain ′ an (η, c + 2)-approximation schedule S from α to β (add {b1, b2} to the cover, then

apply S). Therefore, as G[(α ∪ {b1, b2}) ⊕ β] has at least 2 connected components, we can only reason about the case r > 1.

Now, consider r > 1 and denote by Cα,h the family of all the sets Ci for which

w(Ci ∩ α) > w(Ci ∩ β) and Ci contains a heavy node and denote by Cα,l the family

of all the sets Ci for which w(Ci ∩ α) > w(Ci ∩ β) and Ci contains only light nodes,

similarly, define Cβ,h and Cβ,l for sets Ci with w(Ci ∩ α) ≤ w(Ci ∩ β). Please note that we abuse the above notations sometimes and refer to them as sets of nodes. We now prove that every set C (γ ∈ {α, β}, ξ ∈ {l, h}) admits a (1,O(t(n)))- γ,ξ( ) n approximation schedule of length O t(n) between α and β on the graph induced by G[Cγ,ξ]. With this, see that a schedule which reconfigures Cα,l, Cα,h, Cβ,l and Cβ,h, in

this order, is a valid schedule as there are no edges between G[Cγ,ξ] and G[Cγ′,ξ′ ] if γ ≠ γ′ or ξ ≠ ξ′. To see that the global approximation guarantee follows, note the following:

1. During the reconfiguration of Cα,l, the weight of the cover is at most α + O(t(n)).

2. During the reconfiguration of Cα,h, the weight of the cover is at most:

w(β ∩ Cα,l) + w(α \Cα,l) + O(t(n)) ≤ w(α) + O(t(n)).

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 The inequality follows from the fact that w(β ∩ Cα,l) ≤ w(α ∩ Cα,l).

3. During the reconfiguration of Cβ,l, the weight of the vertex cover is at most w(β)

w(β ∩ Cα) + w(α ∩ Cβ,h) + w(β ∩ Cβ,l) + O(t(n)) ≤ w(β) + O(t(n)),

where Cα = Cα,l ∪ Cα,h. Note that the inequality follows from the fact that

α ∩ Cβ,h ≤ β ∩ Cβ,h.

4. Lastly, during the reconfiguration of Cβ,h, the weight of the cover is at most β + O(t(n)).

Schedule for Cα,l and Cβ,l. To prove that all families have a good reconfiguration

schedule, first note that both Cα,l and Cβ,l are forests of nodes with weight 1. Therefore, the reconfiguration task is the same as the one for unweighted vertex( )covers, andso,by n C Theorem 1.2 we have a (1,O(t(n)))-approximation schedule of length O t(n) on α,l and Cβ,l.

Schedule for Ci ∈ Cα,h. For Cα,h, consider the segments I1,...,Ik of G as de-

scribed above. Let Ci ∈ Cα,h and denote by ki = |{j ∈ [k] | Ij ∩ Ci ≠ ∅}| the number of

segments Ci intersects. Note that every Ci is a path alternating between α-nodes and

β-nodes, and so, we can assume w.l.o.g. that α ∩ Ci = Vodd ∩ Ci and β ∩ Ci = Vbeta ∩ Ci. Let I ,...,I be the segments intersecting C and consider the following schedule: j1 jki i

• V0 = α ∩ Ci.

∪ ∩ \ ∩ • For s = 1, . . . , ki, V2s−1 = V2s−2 (βjs Ci), V2s = V2s−1 (αjs Ci).

Properties of the schedule of Ci: The validity of the schedule follows from the fact that js ∈ − ⊕ ≤ v2t(n)+2 β for all s = 1, . . . , ki 1. For the approximation, see that in w(V0 V1) ∩ ⊕ ⊆ w(β Ij1 ) = (c + 2)t(n) and (V1 V2) α (i.e., only removing nodes), implying that w(V2) ≤ w(α ∩ Ci) + (c + 2)t(n). For s = 2, . . . , ki − 1 we have w(V2s−1 ⊕ V2s−2) =

w(V2s ⊕V2s−1) = (c+2)t(n), implying that w(V2s−1) ≤ w(α∩Ci)+2(c+2)t(n). Finally, w(V − ⊕V − ) ≤ w(β ∩I ) = (c+2)t(n) and (V ⊕V − ) ⊆ α, giving a schedule 2ki 1 2ki 2 jki 2ki 2ki 1 with a cost bounded by 3(c + 2)t(n) = O(t(n)) and a length of O(ki).

Combining Ci ∈ Cα,h Schedules: Consider the schedule of Cα,h in which we reconfigure the C s, one after the other, where we reconfigure C in O(k ) batches, totalling in ∑ i i i ∩ ≤ ∩ ∈ C i∈I O(ki) batches. As w(Ci β) w(Ci α) for all Ci α,h, before the reconfiguration of Ci the weight of the cover is at most w(Cα,h ∩ α). In addition, since every

Ci admits a (1,O(t(n)))-approximation schedule (and w(Ci ∩ β) ≤ w(Ci ∩ α)), during

the reconfiguration of Ci the weight of the cover is at most w(Cα,h ∩ α) + O(t(n)). This means that the computed schedule is a (1,O(t(n)))-approximation schedule of C . ∑ α,h The length of the schedule is i∈I O(ki). To bound this expression, see that every segment Ij can intersect at most 4 connected components in Cα,h. Indeed, if Ij intersects

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 5 connected components C1,...,C5, then at least 3 of them are contained in Ij. As Ij

only contains only 2-heavy nodes, at least one Ci does not contain a heavy node. This is a contradiction, as C ∈ C iff C contains a heavy node. Therefore, we conclude ∑ i (α,h ) i n that i∈I O(ki) = O(k) = O t(n) .

Schedule for Cβ,h. To complete the proof, we reason about the existence of a

schedule from (β ∩ Cβ,h) to (α ∩ Cβ,h). Note that w(Ci ∩ α) ≤ w(Ci ∩ β) for all

Ci ∈ Cβ,h, therefore, a similar reasoning as for Cα,h yields the same result. Then, by

Observation 3.2, reversing this schedule gives the desired schedule for Cβ,h. ■

We now give our main results for this section.

Theorem 6.2. For every ε ∈ (0, 1) and t(n) = o(n), there exists a family G of weighted graphs, on which, for every large enough n:

1. Every n-node graph G ∈ G admits a monotone (1 + ε)-approximation schedule.

2. On an ID space of size Ω(n2), no t(n)-round algorithm can compute a monotone (2 − ε)-approximation schedule of length O(n) on G.

Proof. Let ε ∈ (0, 1) and let t(n) = o(n). Now, let c ∈ N be some constant such that 2 G G c > ε and take = c,t the graph family described above. For the first part of the proof, note that Lemma 6.1 gives a (1,O(t(n)))-approximation schedule for any constant c > 1 and function t(n) = o(n). As M ≥ k(c + 2)t(n) = Θ(n) (M = max{w(α), w(β)}), we have t(n)/M = o(1). Thus, for every constant ε ∈ (0, 1) and for any large enough n, a (1,O(t(n)))-approximation schedule implies that the size of all covers in the schedule is bounded by

O(t(n)) M + O(t(n)) = M + M < M(1 + ε). M

O(t(n)) Where the last inequality holds as M = o(1) < ε for every large enough n. Hence, it is indeed a (1 + ε, 0)-approximation schedule. For the second part of the proof, let A be an algorithm that computes a schedule of length ℓ(n) in t(n) = o(n) rounds. Fix a large enough n and let t = t(n). Consider the

n-node graph G = Gn,t,c ∈ G and let α = Vodd and β = Veven. Our goal is to show that there exists an ID assignment to nodes of G such that, in the schedule computed by A, n all k = 4t(n)+2 heavy β-nodes join the cover at the same time. Before their addition the vertex cover has cost at least w(α) = k(c + 2)t(n), as α is a minimum vertex cover of the graph. Thus, after the addition of the k β-nodes of cost ct(n) each, we obtain a cost of w(α) + kct(n), which translates to a multiplicative approximation of at least

w(α) + kct(n) kct(n) c 2 = 1 + = 1 + > 2 − > 2 − ε. w(α) k(c + 2)t(n) c + 2 c

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 ( ) { }4t(n)+2 ⊆ [ID] Figure 6.1: Segment Ii with IDs in accordance to U = idi i=1 4t(n)+2 . See that i i node vj has ID idj and that the red node, v2t(n)+2, is the only heavy β-node in Ii.

2 A − Due to c > ε we obtain that does not compute a (2 ε)-approximation schedule on on G and yields the desired result.

ID assignment, such that all β-nodes join at the same time. To complete the proof, we have to show that there exists an assignment of IDs to the nodes of G, for which all heavy β-nodes join the cover at the same time. For this, note that in t(n) rounds, each node learns only its t(n)-hop neighborhood, i.e., the 2t(n) + 1 ( ) A [ID] → nodes closest to it. Therefore, we can define a coloring : 4t(n)+2 [ℓ(n)] in the following way: Given a set U = {idi}i∈[4t(n)+2] ordered in an ascending order

(i.e., id1 < id2 < . . . < id4t(n)+2), A(U) is defined to be the time the heavy β-node i ∈ ⊆ v2t(n)+2 Ii joins the cover when the IDs of the segment Ii G are in accordance to i U, that is, the ID of vj is idj for all j = 1,..., 4t(n) + 2 (See Figure 6.1). Recall, that the ID space is of size Ω(n2) and see that (4t(n) + 2)kℓ(n) = O(n2). ( ) { } ⊆ [ID] Therefore, we can take kℓ(n) pairwise disjoint sets of IDs Ui i∈[kℓ(n)] 4t(n)+2 . Since A returns integers between 1 and ℓ(n), by the pigeonhole principle, there are at least A A A k sets Ui1 ,...,Uik for which (Ui1 ) = (Ui2 ) = ... = (Uik ). Therefore, if we set the

IDs of Ij in accordance to Uij for all j = 1, . . . , k, we get that in the computed schedule, all heavy β-nodes join the cover at the same time, giving the desired result. ■

6.2 An Ω(n) Lower Bound for Unweighted Graphs

In this section, we reduce the task of schedule computation on weighted graphs to the same task on unweighted graphs. The lower bound for computing a reconfiguration schedule of weighted vertex cover from Section 6.1 combined with the proposed reduction, imply a lower bound for computing a reconfiguration schedule of unweighted vertex covers. In the proposed reduction, given a weighted graph G = (V, E, w) with w : N → N, we replace each v with w(v) copies of v, and every edge (u, v) is replaced by a complete

bipartite graph Kw(u),w(n) between all copies of u and v. We continue with the formal definition of this graph.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Definition 6.3 (Reduction Graph). Let G = (V, E, w) be a weighted graph with weights w : V → N. We define the Reduction Graph of G as an unweighted graph G′ = (V ′,E′) for which: ∪ ∪ ∪ ′ { }w(v) ′ V = vi i=1 ,E = (ui, vj), v∈V (u,v)∈E i∈[w(u)] j∈[w(v)]

where [k] := {1, 2, . . . , k}. That is, each vertex v ∈ G has corresponding w(v) vertices and every edge (u, v) ∈ E has a corresponding complete bipartite graph denoted by ′ ∼ Gu,v = Kw(u),w(v). → N Given a weighted graph G = (V, E, w) with{ weights w : V} and its reduction ′ ′ ′ ′ graph G = (V ,E ) we denote by corr(v) := v1, . . . , vw(v) ⊆ V the set of w(v) nodes corresponding to v. Given a subset U ⊆ V we extend this notation and denote ∪ ′ ⊆ ′ −1 ′ corr(U) = v∈U corr(v). In addition, given a set U V , we denote corr (U ) = {v ∈ V | corr(v) ⊆ U ′}. We first show a connection between vertex covers of a weighted graph G and covers of its unweighted corresponding graph G′.

Lemma 6.4. Let G = (V, E, w) be a weighted graph with weights w : V → N and let G′ = (V ′,E′) be the unweighted reduction graph of G. The following claims hold:

1. For every vertex cover U of G, the set U ′ := corr(U) is a vertex cover of G′ of size |U ′| = w(U).

2. For every vertex cover U ′ of G′, the set U := corr−1(U ′) is a vertex cover of G of weight w(U) ≤ |U ′|. ∪ Proof. For the first part, see that U ′ = corr(v) and that w(v) = |corr(v)| for all ∑ ∑ v∈U ∈ | | | ′| ′ ′ ∈ ′ v V and so, w(U) = v∈U w(v) = v∈U corr(v) = U . Now, let (u , v ) E and let u, v ∈ V be nodes such that u′ ∈ corr(u) and v′ ∈ corr(v). As (u′, v′) ∈ E′ we must have (u, v) ∈ E, and so, either u ∈ U or v ∈ U. Therefore, we conclude that either u′ ∈ corr(u) or v′ ∈ corr(v) is in U ′. For the second part, see that corr(v) ⊆ U ′ for every v ∈ U, and so, w(U) = ∑ ∑ | | ≤ | ′| v∈U w(v) = v∈U corr(v) U . To show that U is a vertex cover, see that as ′ ∼ ′ every edge (u, v) has a corresponding graph Gu,v = Kw(u),w(v) and as U is a cover ′ ⊆ ′ ⊆ ′ ′ of G , either corr(u) U or corr(v) U (otherwise, Gu,v would have not been covered). ■

Lemma 6.5. Let G = (V, E, w) be a weighted graph with weights w : V → N, let α and β be two vertex covers of G and let G′ = (V ′,E′) be the unweighted reduction graph of G. G admits an (η, c)-approximation schedule of length ℓ between α and β if and only if G′ admits a reconfiguration schedule between corr(α) and corr(β) with the same length and approximation.

Proof. We show both directions of the equivalence separately.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 From weighted to unweighted. Let S = (V0 = α, . . . , Vℓ = β) be an (η, c)- approximation reconfiguration schedule between α and β. Define the following schedule S′ ′ ′ = (V0 = corr(V0),...,Cℓ = corr(Vℓ)). To show validity, first see that by Lemma 6.4, ′ ′ ⊕ ′ every Vi is a vertex cover. Next, to show that every Vi Vi+1 is an independent set, ′ ′ ∈ ′ ⊕ ′ ∈ ′ ∈ ′ ∈ let u , v Vi Vi+1 and let u, v V be nodes such that u corr(u) and v corr(v). ∈ ⊕ ′ ′ ∈ ′ ⊕ ′ ∈ Note that u, v Vi Vi+1 (since u , v Vi Vi+1) and so (u, v) / E, therefore, by the definition of the reduction graph, (u′, v′) ∈/ E′. | ′| For the approximation factor, see that by Lemma 6.4, Vi = w(Vi) for all i = 0, . . . , ℓ, and in special, the initial and final covers admit w(α) = |corr(α)|, w(β) =

|corr(β)|. Therefore, as for every i w(Vi) ≤ η max{w(α), w(β)} + c, we must also have | ′| ≤ {| | | |} S′ S Vi η max corr(α) , corr(β) + c. Therefore, the cost of is the same as of . | ′| | ′| S′ Note that in addition, V0 = w(V0) and Vℓ = w(Vℓ) and so, has an approximation factor of (η, c) as well.

From unweighted to weighted. Now, let α and β be vertex covers of G S′ ′ ′ and let = (V0 = corr(α),...,Vℓ = corr(β)) be a reconfiguration schedule between corr(α) and corr(β). We define the schedule S between α and β as S = ( ) −1 ′ −1 ′ V0 = corr (V0),...,Vℓ = corr (Vℓ ) . To show validity, first see that by Lemma 6.4, ′ ⊕ every Vi is a vertex cover. Next, to show that Vi Vi+1 is an independent set, assume for contradiction that there are u, v ∈ Vi ⊕ Vi+1 such that (u, v) ∈ E. This implies that ′ ∈ ′ ⊕ ′ ∩ ′ ∈ ′ ⊕ ′ ∩ there is some u (Vi Vi+1) corr(u) and some v (Vi Vi+1) corr(v). This is a ′ ′ ∈ ′ ′ ⊕ ′ contradiction, as (u , v ) E by definition of the reduction graph, but Vi Vi+1 must be an independent set since S′ is a valid schedule. | ′| For the approximation factor, see that by Lemma 6.4, w(Vi) = Vi for all i = 0, . . . , ℓ, and in special, the initial and final covers admit |corr(α)| = w(α), |corr(β)| = | ′| ≤ {| | | |} w(β). Therefore, as for every i Vi η max corr(α) , corr(β) + c, we must also have w(Vi) ≤ η max{w(α), w(β)} + c. ■

In the following theorem, we lift the lower bound for weighted vertex cover reconfiguration from Section 6.1 to unweighted vertex cover reconfiguration.

Theorem 6.6. For every ε ∈ (0, 1) and t(n) = o(n), there exists a family G of unweighted graphs, on which, for every large enough n:

1. Every n-node graph G ∈ G admits a monotone (1 + ε)-approximation schedule.

2. On an ID space of size Ω(n2), no t(n)-round algorithm can compute a monotone (2 − ε)-approximation schedule of length O(n) on G.

A 2-connected component of a graph G is an induced sub-graph G′ = G[V ′] for which G[V ′ \{v}] is connected for any v ∈ V ′. To prove the first part of Theorem 6.6, we will use the following known result about the relation between reconfiguration schedules on 2-connected components of G to reconfiguration schedules on G.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Theorem 6.7 ([INZ16, Theorem 2]). Let G = (V,E) be a graph with two vertex covers α and β. If every 2-connected component G′ = (V ′,E′) of G admits a (1, k)- approximation schedule between α∩V ′ and β ∩V ′ then G admits a (1, k)-approximation schedule between α and β.

Proof of Theorem 6.6.

The graph family G. Let ε ∈ (0, 1), let t(n) = o(n) and let h(n) = o(n) such √ that t(n) = o(h(n)) (e.g. h(n) = t(n) · n/t(n)). Now, let Ge be the family of weighted graphs promised by Theorem 6.2 for the parameters ε and h(n), and let G = {G | G is the reduction graph of some Ge ∈ G}e . In addition, recall the construction of Ge and e see that there exists a constant c for which, every( G)has a minimum vertex cover of e e size Ω(ne) and is composed of k = n = O n segments, each contains 4h(ne) 4h(en)+2 h(en) e nodes with weight( 1 and) 2 nodes with weight ch(n). Therefore, the reduction graph G e of Ge has n = O n (4h(ne) + 2ch(ne)) = O(ne) nodes and a minimum vertex cover of h(en) size Ω(n).

Existence of a good schedule. For the first part, let G ∈ G be an n-node reduction graph of an ne-node graph Ge ∈ Ge with n ≥ 3. Let v ∈ β \ α with degree 2, we would like to apply Theorem 6.7 to the graph G′ := G[V \{v}] (which is not 2-connected on its own). Let H be a 2-connected induced sub-graph of G′ with at least 3 vertices (if there is none, G′ admits (1, 1)-approximation schedules). It follows

from the definition of G that H is a complete bipartite graph Ka,b, with 1 ≤ a, b ≤

O(h(ne)) = O(h(n)). For every pair of vertex covers in Ka,b, there is a trivial monotone (1,O(h(n)))-approximation schedule: add all β-vertices, then remove all α-vertices. Theorem 6.7 then implies that there are similar schedules in G′ as well. Therefore, G admits a (1,O(h(n)))-approximation schedule as well, as given a schedule S′ of G′, one can convert it to a (1,O(h(n)) + 1)-approximation schedule of G: add v to the cover, then apply S′. As h(n) = o(n) and as M = max{|α|, |β|} = Ω(n), we get that for every large enough n, a (1,O(h(n)))-approximation schedule implies that the size of all covers in the schedule is bounded by

O(h(n)) M + O(h(n)) = M + M < M(1 + ε). M

Hence, for large enough n, a (1,O(h(n)))-approximation schedule can be interpreted as a (1 + ε, 0)-approximation schedule.

Reduction from an unweighted algorithm to a weighted one For the second part, let A be a t(n) = o(n)-round algorithm which computes an (η, ξ)-approximation schedule of length ℓ(n) = O(n) on G. We will show that algorithm A implies an O(t(ne))- round algorithm Ae which computes an (η, ξ)-approximation schedule on Ge. Therefore,

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 as t(ne) = o(h(n)), by Theorem 6.2, this implies that Ae does not compute a (2 − ε)- schedule on Ge. Combined with Theorem 6.2, we conclude that A does not compute a (1 + ε)-approximation schedule on G as well. Algorithm Ae, on a ne-node graph Ge = (V,e Ee) ∈ Ge, simulates A on the n-node reduction graph G of Ge. The simulation is done by letting each node ve ∈ Ve simulate all nodes in corr(ve) ⊆ V . Note that there is no simulation overhead to simulate an algorithm in graph G on communication graph Ge as for every (u, v) ∈ E the edge (u,e ve) ∈ Ee exists in the communication network. Therefore, from Lemma 6.5 we con-

clude that A˜ computes an (η, ξ)-approximation schedule of G with length ℓ(n) in tA(n) rounds, that is transferred to a schedule of Ge with the same length and approximation. To interpret ℓ(n) and t(n) in terms of ne, the number of nodes of Ge, recall that n = e n (4h(ne) + 2ch(ne)) = O(ne). Therefore, Ae takes t(n) = t(O(ne)) = O(t(ne)) = o(ne) 4h(en)+2 rounds and computes a schedule of length ℓ(n) = ℓ(O(ne)) = O(ℓ(ne)) = O(ne). ■

6.3 An Ω(log∗n) Lower Bound for Unweighted Cycles

In the following section, we complement the O(log∗n/ε) runtime of Corollary 5.1 with a Ω(log∗n) lower bound for computing reconfiguration schedules on unweighted cycles. Our proof uses Ramsey’s theorem. Ramsey theory has been used before to prove distributed lower bounds, e.g., for reproving Linial’s Ω(log∗n) lower bound for coloring cycles with O(1) colors [Suo21], or for lower bounds for approximating independent sets [CHW08]. Our notations in the following definitions are taken from [Rad11]. ( ) S → Definition 6.8. Given a set S and an ℓ-coloring c : k [ℓ] of all k-subsets of S, a subset S′ ⊆ S of size |S′| ≥ k is monochromatic (with color i) if the restriction of c to the k-subsets of S′ is constant (and equals i).

Definition 6.9 (Ramsey Number). For ℓ, k, r ∈ N with k ≤ r, the Ramsey Number

Rℓ(k, r) is the least m ∈ N such that, given a set S of size m, for every ℓ-coloring of k-subsets of S, there is a monochromatic r-subset S′ ⊆ S.

In the lemma below, we use Knuth’s arrow notation, where a ↑↑ b is a tower of a’s of height b.

∗ Lemma 6.10. For all ℓ, k, r ≥ 2, k ≤ r, it holds that Rℓ(k, r) ≤ 2 ↑↑ (k log ℓ + log∗(2rℓ)).

k−1 k−2 2 Proof. From [ER52, Theorem 1], we know that Rℓ(k, r) ≤ ℓ ∗ (ℓ ) ∗ (ℓ ) ∗ · · · ∗ (ℓ ) ∗ (rℓ), where a ∗ b := ab, and a ∗ b ∗ c = a ∗ (b ∗ c). Since the top exponent rℓ is larger than k and ℓ ≥ 2, it is easy to see that replacing ℓi with ℓ in the expression above, for all i, and adding k to the top exponent, does not decrease its value. Thus, we have ∗ ∗ Rℓ(k, r) ≤ ℓ ∗ · · · ∗ ℓ ∗ (2rℓ). Since ℓ ≤ 2 ↑↑ log ℓ, we replace each ℓ with 2 ↑↑ log ℓ and 2rℓ with 2 ↑↑ log∗(2rℓ), to get the claimed bound. ■

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Theorem 6.11. Let ε ∈ (0, 1) be a constant, let ℓ : N → N be a function such that

ℓ(n) < n and let C = {Cn | n ∈ 2N} be the family of even cycles. Given an ID space of size Ω(nℓ log n), any T = T (n, ℓ(n))-round algorithm A which computes a monotone ℓ(n)-batch (2 − ε)-approximation schedule on C for every large enough n must have a runtime of T = Ω(log∗ n/ log∗ ℓ) rounds.

log∗ n Proof. Assume, for a contradiction, that T (n, ℓ) < 4 log∗ ℓ , for some sufficiently large even n and ℓ < n. Consider Cn, and assume, for simplicity, the nodes are labeled with IDs from [R], where R = ⌈nℓ log n⌉ (the proof can easily adapted for any R = Ω(nℓ log n)). Let α, β, α ∩ β = ∅ be disjoint minimum vertex covers; note that the

nodes in Cn alternate between α and β.

A defines a coloring of (2T + 1)-sized subsets of R. In T rounds, each node v learns the IDs and type (α or β) of its T -hop neighborhood, i.e., the 2T + 1 nodes closest to it. This information is determined by the (2T + 1)-tuple of the IDs and the type of v, since the types of other nodes are uniquely determined by the type of v and the distance from it. Moreover, we will only focus on nodes v whose (2T + 1)-tuple is an increasing sequence; hence, the sequence is determined by the set of (2T + 1) IDs. The output of v is the batch number where it is processed (recall that the schedule is ( ) A A { } × R → monotone). As such, algorithm corresponds to a function : α, β 2T +1 [ℓ], which, given the set S of IDs of the nodes on the (2T + 1)-path with center node v, and the type of v, outputs the batch number of v. Our aim is to assign the IDs of nodes so that there is one batch where many β-nodes are added; therefore, we only focus on β-nodes, and drop the type parameter of A.

There are many monochromatic subsets. By the discussion above, we can view algorithm A (when restricted to β-nodes with a monotone ID sequence in the

neighborhood) as an ℓ-coloring of (2T + 1)-subsets from [R]. Let X = Rℓ(2T + 1, 2cT +

2T ), where c = ⌈2/ε⌉. If R > X, by the definition of the Ramsey number Rℓ(2T + 1, 2cT + 2T ), there exists a monochromatic subset S ⊆ [R] of size 2cT + 2T . Hence, one can assign the nodes on an induced path P ⊆ G of length 2cT + 2T IDs from S, T in increasing order of IDs. Therefore, as the T -hop neighborhood N (vi) of at least

cT β-nodes vi ∈ P are all 2T + 1-sized subsets of S. As S is monochromatic, each T such subset N (vi) is mapped to the same color under A, i.e., each of the cT β-nodes maps join the cover at the same time. Now, see that if R > mX for some integer m,

we can take m disjoint subsets of [R], U1,...,Um, each of size X, and apply the above

reasoning for each Ui to obtain m disjoint monochromatic subsets, S1,...,Sm (there are m separate applications of ’Ramsey’). To bound m, the number of monochromatic subsets, by Lemma 6.10 we know that log∗ X ≤ (2T + 1) log∗ ℓ + log∗(8cT ℓ). Assuming log∗ n n is large enough with respect to c and ℓ, and recalling that T < 4 log∗ ℓ , we have that X < log n. Therefore, we can take m := ⌊R/X⌋ ≥ ⌈nℓ log n⌉/ log n ≥ nℓ to obtain

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 disjoint monochromatic subsets S1,...,Sm.

Many monochromatic subsets have the same color. While each of the m

subsets S1,...,Sm is monochromatic, they might be monochromatic with regard to different colors. But, by the pigeonhole principle, there is acolor t ∈ [ℓ] such that

at least m/ℓ ≥ n of them are monochromatic with regard to t. Let S1,...,Ss be

s := ⌈n/(2cT + 2T )⌉ of those subsets. We assign the IDs on Cn, by partitioning the

cycle into paths P1,...,Ps, each of length 2cT + 2T (except perhaps one), and assign

the nodes on Pi the IDs from Si, in increasing order of IDs. For each Pi, perhaps except for one, it holds that cT of its β-nodes, namely the ones for which the set of

IDs of the T -neighborhood is entirely in Si, output t. Over the whole graph, at least (n/(2cT +2T )−1)·cT of the β-nodes output t. Just before the t-th batch of the schedule, we have a vertex cover that is at least as large as M = max(|α|, |β|) = n/2 (since those are minimal vertex covers). In the t-th batch, we add the mentioned β-vertices, getting a vertex cover of size ( ) ( ) ncT c cT 1 2c log∗ n M + −cT = 1 + − M ≥ 2 − − M > (2−ε)M, 2cT + 2T c + 1 M c + 1 n

recalling that c ≥ 2/ε, and assuming n is large enough so that 2c log∗ n/n < ε/2. Thus, algorithm A gives a schedule whose approximation factor is more than (2 − ε) for the log∗ n ■ constructed instance. Thus, the assumption that T < 4 log∗ ℓ leads to a contradiction.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 56

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Chapter 7

Conclusion and open questions

In this thesis we have presented the concept of batched vertex cover reconfiguration and asked what can and cannot be done, both in centralized and distributed settings. Previous works have either shown hardness results for vertex cover reconfiguration or proved that there always exists a good monotone schedule. As such, we have focused on monotone schedules. A begging question regarding this assumption is whether there exists natural graph family for which finding the optimal (sequential) reconfiguration schedule can be done in polynomial time, even when the optimal schedule is not monotone? Additionally, we note that our compression scheme only applies for monotone schedules, and the task of compressing non-monotone schedules is also of interest. Even when only considering monotone schedules, we observe that our compression scheme provides batched schedules for graphs G for which G[α ⊕ β] is a cactus graph, which is aligned with known results for sequential schedule. It would be interesting to see whether such results can be extended to wider families of graphs, such as outer- planar graphs (a graph is outer-planar if it has a planar drawing for which all vertices belong to the outer face of the drawing). For the distributed setting, similar tasks can be considered as well. We have shown that a small separator decomposition can be computed super-fast on several families of graphs, and extending our results to a wider class of graphs is appealing as well. In addition, we observe that some of our results, such as the cluster merging algorithm, immediately extend to the CONGEST model, in which the size of messages is restricted to O(log n) bits. Yet, some of our results would incur a large overhead in run-time if directly converted to CONGEST, and it is an intriguing question whether there are faster solutions.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 58

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Bibliography

[AGLP89] Baruch Awerbuch, Andrew V. Goldberg, Michael Luby, and Serge A. Plotkin. Network decomposition and locality in distributed computation. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 364–369, 1989.

[BB14] Marthe Bonamy and Nicolas Bousquet. Reconfiguring independent sets in cographs. CoRR, abs/1406.1433, 2014.

[BC09] Paul S. Bonsma and Luis Cereceda. Finding paths between graph colourings: Pspace-completeness and superpolynomial distances. Theor. Com- put. Sci., 410(50):5215–5226, 2009.

[BHI+20] Marthe Bonamy, Marc Heinrich, Takehiro Ito, Yusuke Kobayashi, Haruka Mizuta, Moritz Mühlenthaler, Akira Suzuki, and Kunihiro Wasa. Shortest reconfiguration of colorings under kempe changes. In 37th International Symposium on Theoretical Aspects of Computer Science, STACS 2020, March 10-13, 2020, Montpellier, France, pages 35:1–35:14, 2020.

[BKW14] Paul S. Bonsma, Marcin Kaminski, and Marcin Wrochna. Reconfiguring independent sets in claw-free graphs. In R. Ravi and Inge Li Gørtz, editors, Algorithm Theory - SWAT 2014 - 14th Scandinavian Symposium and Workshops, Copenhagen, Denmark, July 2-4, 2014. Proceedings, volume 8503 of Lecture Notes in Computer Science, pages 86–97. Springer, 2014.

[Bon16] Paul Bonsma. Independent set reconfiguration in cographs and their gen- eralizations. Journal of Graph Theory, 83(2):164–195, 2016.

[BOR+18] Marthe Bonamy, Paul Ouvrard, Mikaël Rabie, Jukka Suomela, and Jara Uitto. Distributed recoloring. In 32nd International Symposium on Dis- tributed Computing, DISC 2018, New Orleans, LA, USA, October 15-19, 2018, pages 12:1–12:17, 2018.

[CHW08] Andrzej Czygrinow, Michal Hanckowiak, and Wojciech Wawrzyniak. Fast distributed approximations in planar graphs. In Gadi Taubenfeld, editor,

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Distributed Computing, 22nd International Symposium, DISC 2008, Arca- chon, France, September 22-24, 2008. Proceedings, volume 5218 of Lecture Notes in Computer Science, pages 78–92. Springer, 2008.

[CR19] Keren Censor-Hillel and Mikaël Rabie. Distributed reconfiguration of maximal independent sets. In 46th International Colloquium on Automata, Languages, and Programming, ICALP 2019, July 9-12, 2019, Patras, Greece, pages 135:1–135:14, 2019.

[CV86] Richard Cole and Uzi Vishkin. Deterministic coin tossing with applications to optimal parallel list ranking. Inf. Control, 70(1):32–53, July 1986.

[CvdHJ08] Luis Cereceda, Jan van den Heuvel, and Matthew Johnson. Connectedness of the graph of vertex-colourings. Discret. Math., 308(5-6):913–919, 2008.

[dBJM18] Mark de Berg, Bart M. P. Jansen, and Debankur Mukherjee. Independent- set reconfiguration thresholds of hereditary graph classes. Discret. Appl. Math., 250:165–182, 2018.

[DDFE+15] Erik D. Demaine, Martin L. Demaine, Eli Fox-Epstein, Duc A. Hoang, Takehiro Ito, Hirotaka Ono, Yota Otachi, Ryuhei Uehara, and Takeshi Yamada. Linear-time algorithm for sliding tokens on trees. Theoretical Computer Science, 600:132 – 142, 2015.

[ER52] P. Erdós and R. Rado. Combinatorial Theorems on Classifications of Subsets of a Given Set. Proceedings of the London Mathematical Society, s3-2(1):417–439, 01 1952.

[FK20] Salwa Faour and Fabian Kuhn. Approximate bipartite vertex cover in the congest model. In OPODIS, 2020.

[GHS83] R. G. Gallager, P. A. Humblet, and P. M. Spira. A distributed algorithm for minimum-weight spanning trees. ACM Trans. Program. Lang. Syst., 5(1):66–77, January 1983.

[GKM17a] Mohsen Ghaffari, Fabian Kuhn, and Yannic Maus. On the complexity of local distributed graph problems. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, pages 784–797, New York, NY, USA, 2017. ACM.

[GKM17b] Mohsen Ghaffari, Fabian Kuhn, and Yannic Maus. On the complexity of local distributed graph problems. In Proceedings of the ACM Symposium on Theory of Computing (STOC), pages 784–797. ACM, 2017.

[GKP98] Juan A. Garay, Shay Kutten, and David Peleg. A sublinear time distributed algorithm for minimum-weight spanning trees. SIAM J. Comput., 27(1):302–316, 1998.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 [HD05] Robert A. Hearn and Erik D. Demaine. Pspace-completeness of sliding- block puzzles and other problems through the nondeterministic constraint logic model of computation. Theor. Comput. Sci., 343(1-2):72–96, 2005.

[HL06] Shlomo Hoory and Nathan Linial. Expander graphs and their applications. Bulletin of the American Mathematical Society, 43:439–561, 2006.

[HU16] Duc A. Hoang and Ryuhei Uehara. Sliding tokens on a cactus. In Seok-Hee Hong, editor, 27th International Symposium on Algorithms and Computa- tion, ISAAC 2016, December 12-14, 2016, Sydney, Australia, volume 64 of LIPIcs, pages 37:1–37:26. Schloss Dagstuhl - Leibniz-Zentrum für In- formatik, 2016.

[IDH+11] Takehiro Ito, Erik D. Demaine, Nicholas J.A. Harvey, Christos H. Pa- padimitriou, Martha Sideri, Ryuhei Uehara, and Yushi Uno. On the complexity of reconfiguration problems. Theoretical Computer Science, 412(12):1054 – 1065, 2011.

[IKD12] Takehiro Ito, Marcin Kaminski, and Erik D. Demaine. Reconfiguration of list edge-colorings in a graph. Discret. Appl. Math., 160(15):2199–2207, 2012.

[IKK+19] Takehiro Ito, Naonori Kakimura, Naoyuki Kamiyama, Yusuke Kobayashi, and Yoshio Okamoto. Shortest reconfiguration of perfect matchings via alternating cycles. In 27th Annual European Symposium on Algorithms, ESA 2019, September 9-11, 2019, Munich/Garching, Germany, pages 61:1– 61:15, 2019.

[INZ16] Takehiro ITO, Hiroyuki NOOKA, and Xiao ZHOU. Reconfiguration of vertex covers in a graph. IEICE Transactions on Information and Systems, E99.D(3):598–606, 2016.

[JKK+16] Matthew Johnson, Dieter Kratsch, Stefan Kratsch, Viresh Patel, and Daniël Paulusma. Finding shortest paths between graph colourings. Al- gorithmica, 75(2):295–321, 2016.

[KMM12] Marcin Kaminski, Paul Medvedev, and Martin Milanic. Complexity of independent set reconfigurability problems. Theor. Comput. Sci., 439:9– 15, 2012.

[Lin92] Nati Linial. Locality in distributed graph algorithms. SIAM Journal on Computing, 21(1):193–201, 1992.

[LM19] Daniel Lokshtanov and Amer E. Mouawad. The complexity of independent set reconfiguration on bipartite graphs. ACM Trans. Algorithms, 15(1):7:1–7:19, 2019.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 [LS93] N. Linial and M. Saks. Low diameter graph decompositions. Combinator- ica, 13(4):441–454, 1993.

[MNRS18] Amer Mouawad, Naomi Nishimura, Venkatesh Raman, and Sebastian Siebertz. Vertex cover reconfiguration and beyond. Algorithms, 11(2):20, Feb 2018.

[MSS15] Adam Marcus, Daniel A. Spielman, and Nikhil Srivastava. Interlacing families i: bipartite ramanujan graphs of all degrees. Annals of Mathematics, 182:307–325, 2015.

[Nis18] Naomi Nishimura. Introduction to reconfiguration. Algorithms, 11(4):52, 2018.

[NW64] C. St.J. A. Nash-Williams. Decomposition of Finite Graphs Into Forests. Journal of the London Mathematical Society, s1-39(1):12–12, 01 1964.

[Pel00] David Peleg. Distributed computing. SIAM Monographs on discrete mathematics and applications, 5, 2000.

[Rad11] Stanisław P. Radziszowski. Small Ramsey numbers. The Electronic Journal of Combinatorics, page Dynamic Survey DS1, 2011. http: //www.combinatorics.org/ojs/index.php/eljc/article/view/DS1.

[RG20] Václav Rozhon and Mohsen Ghaffari. Polylogarithmic-time deterministic network decomposition and distributed derandomization. In Konstantin Makarychev, Yury Makarychev, Madhur Tulsiani, Gautam Kamath, and Julia Chuzhoy, editors, Proccedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020, pages 350–363. ACM, 2020.

[Sol18] Shay Solomon. Local algorithms for bounded degree sparsifiers in sparse graphs. In Anna R. Karlin, editor, 9th Innovations in Theoretical Com- puter Science Conference, ITCS 2018, January 11-14, 2018, Cambridge, MA, USA, volume 94 of LIPIcs, pages 52:1–52:19. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018.

[Suo21] Jukka Suomela. Distributed algorithms, Online textbook, 2021. URL: https://jukkasuomela.fi/da/da-screen.pdf.

[Tan84] Robert Michael Tanner. Explicit concentrators from generalized n-gons. Siam Journal on Algebraic and Discrete Methods, 5:287–293, 1984.

[Wro18] Marcin Wrochna. Reconfiguration in bounded bandwidth and tree-depth. J. Comput. Syst. Sci., 93:1–10, 2018.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 בצמתים α, β כך ש-[G[α ⊕ β הוא קקטוס, קיים אלגוריתם במודל ה-LOCAL שמחשב תכנית רקונפיגורציה מאורך (O(1/ε שמהווה (ε, 3 + 1)-קירוב תוך (O(log∗n/ε סיבובי תקשורת.

לאחר מכן, אנו מראים שניתן לחשב במהירות תכניות רקונפיגורציה מבוססות דרגה, ללא שימוש בפירוק עם מפרידים, אך באורך גדול בהרבה מהתכנית מאורך 4 שהוצגה בחלק הסדרתי של התוצאות: עבור גרף עם λ arboricity, ניתן לחשב תכנית רקונפיגורציה מבוססת דרגה מאורך (O(λ/ε2 אשר מהווה (1/2λ + ε, 1 − 2)-קירוב תוך (O(log∗n/ε סיבובים במודל ה-LOCAL.

בניסיון להאיץ תכניות אלו עוד יותר, אנו מראים שניתן לנצל את מרחב המזהים על מנת לחשב תכנית רקונפיגורציה מבוססת דרגה עם קירוב של (λ, 1/1 − 2) בסיבוב תקשורת אחד, אך מאורך של ((O(∆f(n כאשר ∆ היא הדרגה המקסימלית בגרף ו-(f(n הוא המזהה הגדול ביותר האפשרי בגרף עם n צמתים.

התוצאות לעיל מראות שכאשר בפירוק כלשהו של הגרף יש לכל מחלקה תכנית רקונפיגורציה בעלת קירוב טוב, ניתן לחשב תכנית רקונפיגורציה לכל הגרף. אנו מראים שתנאי זה הוא הכרחי, במובן הבא: ישנם גרפים עבורם קיימת תכנית רקונפיגורציה בעלת קירוב טוב, אך רק משום שבכל פירוק תהיינה הרבה מחלקות שבהן אין קירוב טוב, אף אלגוריתם יעיל לא יוכל לחשב תכנית רקונפיגורציה טובה במודל ה-LOCAL. פורמלית, אנחנו מראים שלכל ε > 0 ולכל פונקציה (t(n) = o(n קיימת משפחה אינסופית של גרפים בה לכל גרף יש תכנית רקונפיגורציה שמהווה (ε, 0 + 1)-קירוב בין כל שני כיסויים בצמתים, אך קיימים כיסויים בצמתים α ו-β עליהם כל אלגוריתם שרץ לכל היותר (t(n סיבובים לא יחשב תכנית רקונפיגורציה שמהווה פחות מ-(ε, 0 − 2)-קירוב.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 דרגה, אשר מהווה (1/2λ, 1 − 2)-קירוב עבור גרפים עם λ arboricity.

בנוסף לתכניות מבוססות הדרגה הסדרתיות, אנו מנצלים את פשטותן של תכניות אלו ומראים שניתן לדחוס אותן, באופן שונה מאלגוריתם הקופסא השחורה, לתכניות בקבוצות בעלות 4 צעדים בלבד, מבלי לפגוע כמעט בכלל בהבטחת הקירוב. למעשה, אנו מראים שתכניות אלו מהוות + 2λ)/1 − 2) (1 ,(-1קירוב (לעומת (1/2λ, 1 − 2)-קירוב עבור התכניות הסדרתיות).

רקונפיגורציה מבוזרת של כיסויים בצמתים

תכנית רקונפיגורציה בקבוצות יכולה לעלות באופן טבעי במערכות שבהן הצמתים עצמם, כמכונות חישוב אוטונומיות, נדרשים לחשב תכניות רקונפיגורציה ולבצע אותן על-ידי שליחת הודעות והחלפת מידע.

בחלק המבוזר של תזה זו, אנו מתמקדים במודל ה-LOCAL, בו המחשבים ורשת התקשורת מיוצגים על-ידי גרף (G = (V,E, כאשר כל צומת מייצג מכונה וכל קשת מייצגת ערוץ תקשורת. התקשורת מתבצעת באופן סינכרוני, כאשר בכל סיבוב תקשורת, כל צומת שולח הודעה מגודל לא מוגבל לכל אחד משכניו, מקבל מהם הודעות ומבצע חישוב. בנוסף, לכל צומת יש מזהה ייחודי מתוך מרחב מגודל פולינומי ב-| V|. נאמר שצמתי G מחשבים תכנית רקונפיגורציה במודל ה- LOCAL אם כל צומת בגרף יודע מתי הוא נכנס לכיסוי/יוצא ממנו. כמו כן, נדגיש שבמודל ה-LOCAL, בנוסף לאורך התכנית ומחירה, מדד נוסף הוא מספר סיבובי התקשורת הנדרשים על מנת לחשב את תכנית הרקונפיגורציה.

תוצאות המחקר במודל המבוזר

השיטה העיקרית לחישוב תכניות רקונפיגורציה במודל ה-LOCAL מתבססת על פירוק עם מפרידים של הגרף, אותו הגדרנו על מנת להתמודד עם משימה זו, אך ייתכן שיהיה שימושי לפתרון בעיות נוספות.

בפירוק זה, בהינתן גרף (G = (V,E, אנו מפצלים את V למחלקות C1,...,Ck וקבוצה S, קטנה ככל הניתן, של מפרידים. בקצרה, בפירוק עם מפרידים אנחנו מעוניינים במחלקות עם קוטר קטן, על מנת שנוכל לחשב במהירות תכניות רקונפיגורציה בכל מחלקה. כמו כן, על מנת שנוכל לבצע את תכניות הרקונפיגורציה בו-זמנית על כל המחלקות השונות, עלינו לדרוש שלא תהיינה אף קשת בין שתי מחלקות שונות, ולשם כך, אנו נעזרים בקבוצת המפרידים S.

באופן פורמלי, בהינתן גרף (G = (V,E עם שני כיסויים בצמתים α ו-β ופירוק עם מפרידים

C1,...,Ck,S כך שלכל מחלקה של קוטר של לכל יותר d. אם עבור כל מחלקה קיימת תכנית רקונפיגורציה שהיא (η, c)-קירוב מאורך ℓ, אז קיימת תכנית רקונפיגורציה בין α ל-β שהיא +|η, |S) (k · c-קירוב מאורך 2ℓ + 2 אשר ניתנת לחישוב ב-(O(d סיבובי תקשורת במודל ה-LOCAL.

הכלי המרכזי שאנו משתמשים בו לחישוב פירוק עם מפרידים הינו אלגוריתם מיזוג מחלקות. עבור משפחות מסויימות של גרפים, אנחנו מראים שבעזרת אלגוריתם זה ניתן לחשב במהירות ((O(log∗ n/ε סיבובי תקשורת) פירוק עם מפרידים. בפרט, חישוב זה נותן פירוק עם מפרידים עבור גרפים בהם [G[α ⊕ β הינו גרף קקטוס.

בעזרת פירוק זה לגרפי קקטוס, אנחנו מראים שלכל ε > 0, בהינתן גרף (G = (V,E ושני כיסויים

iii

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 שדרישה זו שקולה לחיוב קבוצת הצמתים המשתנים בכל צעד להוות קבוצה בלתי תלויה (כלומר, קבוצה I ⊆ V כך שלכל u, v ∈ I מתקיים u, v) ∈/ E)).

מדדים לאיכותן של תכניות רקונפיגורציה

כאשר אנו מחשבים תכנית רקונפיגורציה בין שני כיסויים בצמתים, לרוב מסומנים בתור α ו-β, השינוי של מספר רב של צמתים מאפשר מציאת תכניות רקונפיגורציה קצרות, אך מגדיל את גודל הכיסויים בכל אחד משלבי הפיתרון. אנו מראים בעזרת עקרון שובך היונים, שישנם כיסויים בצמתים α ו-β, עבורם בכל תכנית רקונפיגורציה מאורך t קיים כיסוי שגודלו לכל הפחות {|t) max{|α|, |β/1 + 1). לכן, המטרה המרכזית שלנו היא להתקרב כמה שניתן ליחס אורך-גודל המיטבי הנ״ל. אנחנו מודדים את איכות התכנית בעזרת שני מדדים: הראשון, הוא אורך התכנית, כלומר, מספר הצעדים שיש לבצע כדי לעבור מ-α ל-β. השני, הוא מחיר התכנית, כלומר, הגודל המקסימלי של כיסוי בתכנית נתונה. בעקבות דרישת היציבות, מדד זה כולל בתוכו גם כל כיסוי בצמתים שעלול להתקבל בכל מעבר סדרתי בין שני כיסויים עוקבים בתכנית.

לאור העובדה שלכל תכנית רקונפיגורציה יש מחיר של לפחות {|max{|α|, |β, נאמר שתכנית רקונפיגורציה היא (η, c)-קירוב אם מחירה הוא לכל היותר η max{|α|, |β|} + c. לרוב, נניח ש-η הינו מספר בין 1 ל2- וכן ש-c הוא קבוע.

תוצאות המחקר במודל הסדרתי

התוצאה הראשונה בתזה זו מתארת קשר בין תכניות מונוטונות של רקונפיגורציה סדרתית, כלומר, תכניות בהן כל צומת משנה את מצבה לכל היותר פעם אחת, לתכניות מונוטוניות של רקונפיגורציה בקבוצות. יחס זה למעשה מתאר דחיסה של תכניות סדרתיות אשר ניתן להפעיל כ-״קופסא-שחורה״ על תכניות מסוג זה ולקבל תכניות רקונפיגורציה בקבוצות בזמן פולינומי: בהינתן ε > 0 ותכנית מונוטונית של רקונפיגורציה סדרתית אשר ידוע שהיא (η, c)-קירוב, אנו מראים שניתן ״לדחוס״ אותה לתכנית רקונפיגורציה בקבוצות מאורך (O(1/ε, אשר מהווה (η +ε, c+1)-קירוב. אנו מראים שדחיסה זו הינה אופטימלית במקרים מסויימים.

גרפי קקטוס הם גרפים בהם כל קשת נמצאת במעגל אחד לכל היותר. עבור גרפי קקטוס ידוע שתמיד קיימת תכנית (2 ,1)-קירוב מונוטונית בין כל שני כיסויים בצמתים. בעזרת מנגנון הדחיסה, עבור גרפים בהם [G[α ⊕ β הינו גרף קקטוס ((α ⊕ β := (α \ β) ∪ (β \ α). אנו מראים שניתן לחשב תכניות רקונפיגורציה בעלות יחס אורך-מחיר כמעט אופטימלי עם אורך (O(1/ε וקירוב של .(1 + ε, 3)

לאחר מכן, אנו שואלים האם ניתן להרחיב את התוצאות לעיל למשפחות נוספות של גרפים, כמו למשל גרפים עם דרגה חסומה, או גרפים בעלי arboricity חסום (arboricity של גרף היא המספר המינימלי של יערות אשר ניתן לכסות בעזרתן את כל הקשתות). אנחנו מוכיחים שזה אינו המצב ומראים שלכל d > 0 קיימת משפחה אינסופית של גרפים d-רגולריים (גרפים שדרגת כל הצמתים בהם היא d) √עם זוגות של כיסויים בצמתים עבורה לא קיימת תכנית רקונפיגורציה סדרתית בעלות פחות מ-((O(1/ d − 2)-קירוב לאף גרף. בצד החיובי, אנחנו מראים תכנית סדרתית מבוססת

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 תקציר

בבעיות אופטימיזציה קלאסיות, לעיתים קרובות אנו מחפשים תת-קבוצה של איברים מתוך קבוצה גדולה יותר, קטנה או גדולה ככל הניתן, כך שתקיים תנאים כלשהם. למשל, בהינתן גרף (G = (V,E, אנו מחפשים כיסוי בצמתים קטן ביותר, כלומר, קבוצה C ⊆ V קטנה ככל הניתן עבורה לכל קשת יש לפחות קצה אחד ב-C. בבעיות רקונפיגורציה אנחנו מנסים לעבור מפתרון אחד של בעיה לפתרון אחר אליה על ידי שינוי של איבר אחד בכל צעד (בדוגמה, הוצאה מ-C או הכנסה אליו) תוך שמירה על נכונות הפתרון (בדוגמה, שמירה על C ככיסוי בצמתים), לסדרת מעברים זו אנו קוראים תכנית רקונפיגורציה סדרתית. שאלה מרכזית בבעיות מסוג זה היא שאלת הישיגות: בהינתן שני פתרונות לבעיה, האם ניתן לעבור מפתרון אחד לשני תוך שמירה על נכונות הפתרון תחת אילוצים אפשריים נוספים (בדוגמה למשל, ניתן להוסיף מגבלה k על גודל הכיסוי C).

רקונפיגורציה של כיסויים בצמתים

בהינתן גרף (G = (V,E, כיסוי בצמתים היא תת-קבוצה C ⊆ V של הצמתים, כך שלכל קשת u, v) ∈ E) בגרף מתקיים או u ∈ C או v ∈ C. בבעית הישיגות של כיסויים בצמתים, אנו מקבלים כקלט פרמטר k > 0, גרף (G = (V,E ושני כיסויים בצמתים של α ,G ו-β מגודל לכל היותר k ושואלים: ״האם קיימת תכנית רקונפיגורציה מ-α ל-β אשר שומרת על כיסוי בצמתים מגודל לכל היותר k?״.

בתזה זו, מטרתינו היא לקצר תכניות רקונפיגורציה על-ידי שימוש במקביליות עבור תהליכים אלו, אשר קיימת באופן טבעי במערכות בהן מספר צמתים יכולים להשתנות בו זמנית. ברקונפיגורציה של כיסויים בצמתים, דבר זה מתבטא ביכולת של מספר צמתים בגרף להצטרף לכיסוי או לצאת ממנו. כדי ללמוד תהליכים אלו, אנו מציגים את המושג רקונפיגורציה בקבוצות של כיסויים בצמתים.

בתכנית רקונפיגורציה בקבוצות, אנחנו מאפשרים את שינויים של מספר בלתי מוגבל של צמתים בו- זמנית, זאת לעומת רקונפיגורציה סדרתית, בה אנחנו מאפשרים את השינוי של צומת אחד בלבד. תכניות רקונפיגורציה בקבוצות אינן בהכרח יציבות, כלומר, נניח שבמערכת הנתונה, ההנחיה לשינוי אינה מתבצעת מיד, אלא עלולה לקחת כמות כלשהי של זמן. אם כן, למרות שאנו רוצים לשנות מספר צמתים בו-זמנית, בפועל הדבר עלול לגרום לסדרת שינויים כלשהי. כך למשל, בהינתן שני כיסויים בצמתים, המעבר (הסדרתי) ביניהם עלול לכלול בתוכו קבוצה שאינה כיסוי ולפגוע בנכונות התכנית.

לאור זאת, נדרוש מכל תכנית רקונפיגורציה בקבוצות להיות יציבה. כלומר, נדרוש שכל קבוצה שעלולה להתקבל במעבר בין שני כיסויים עוקבים בתכנית תהווה גם היא כיסוי בצמתים. אנו מראים

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 המחקר בוצע בהנחייתה של פרופסור קרן צנזור-הלל, בפקולטה למדעי המחשב.

תודות

אני מודה למנחה שלי, פרופסור קרן צנזור-הלל, על ההדרכה, הסבלנות והתמיכה האקדמית. אני רוצה להודות גם לטיגראן טונויאן ויאניק מאוס על הזמן הרב וההשקעה בי. כמו כן, אני רוצה להודות להורי, למשפחתי ולחברי על העידוד והנחת שהביאו לי בתקופה זו.

אני מודה לקרן פורשהיימר ולטכניון על התמיכה הכספית הנדיבה בהשתלמותי.

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021 רקונפיגורציה בקבוצות של כיסויים בצמתים

חיבור על מחקר

לשם מילוי חלקי של הדרישות לקבלת התואר מגיסטר למדעים במדעי המחשב

שחר רומם פלד

הוגש לסנט הטכניון — מכון טכנולוגי לישראל אדר התשפ"א חיפה מרץ 2021

שחר רומם פלד

Technion - Computer Science Department - M.Sc. Thesis MSC-2021-09 - 2021