0/1/all CSPs, Half-Integral $A$-path Packing, and Linear-Time FPT Algorithms
Yoichi Iwata, Yutaro Yamaguchi, Yuichi Yoshida

TL;DR
This paper introduces a fast $O(km)$-time LP solving algorithm for FPT problems, enabling linear-time algorithms with minimal parameter dependency for several complex graph problems.
Contribution
It presents a novel $O(km)$ algorithm for solving LP relaxations in FPT algorithms, improving efficiency and enabling linear-time solutions for multiple problems.
Findings
Achieved linear-time FPT algorithms for Group Feedback Vertex Set and Non-monochromatic Cycle Transversal.
Developed an $O(km)$ LP solving algorithm based on 0/1/all constraints and $A$-path packing.
Provided the first linear-time FPT algorithms for certain graph problems.
Abstract
A recent trend in the design of FPT algorithms is exploiting the half-integrality of LP relaxations. In other words, starting with a half-integral optimal solution to an LP relaxation, we assign integral values to variables one-by-one by branch and bound. This technique is general and the resulting time complexity has a low dependency on the parameter. However, the time complexity often becomes a large polynomial in the input size because we need to compute half-integral optimal LP solutions. In this paper, we address this issue by providing an -time algorithm for solving the LPs arising from various FPT problems, where is the optimal value and is the number of edges/constraints. Our algorithm is based on interesting connections among 0/1/all constraints, which has been studied in the field of constraints satisfaction, -path packing, which has been studied in the…
| Problem | Smallest | Existing linear-time FPT | Our result |
| 0/1/all Deletion | [19] | — | |
| Node Unique Label Cover | [19] | [23] | |
| Two-fan Deletion | [19] | — | |
| Monochromatically | — | — | |
| Orientable Deletion | |||
| Subset Pseudoforest | — | — | |
| Deletion | |||
| Node Multiway Cut | [9] | [6, 18] | |
| Group FVS | [19] | — | |
| Subset FVS | [19] | (randomized) [21] | |
| (deterministic) [21] | |||
| Non-monochromatic | [33] | — | |
| Cycle Transversal |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsOptimization and Packing Problems · Formal Methods in Verification · graph theory and CDMA systems
0/1/all CSPs, Half-Integral -path Packing,
and Linear-Time FPT Algorithms
Yoichi Iwata
National Institute of Informatics
[email protected] Supported by JSPS KAKENHI Grant Number JP17K12643.
Yutaro Yamaguchi
Osaka University
[email protected] Supported by JSPS KAKENHI Grant Number JP16H06931 and JST ACT-I Grant Number JPMJPR16UR.
Yuichi Yoshida
National Institute of Informatics
[email protected] Supported by JST ERATO Grant Number JPMJER1305 and JSPS KAKENHI Grant Number JP17H04676.
Abstract
A recent trend in the design of FPT algorithms is exploiting the half-integrality of LP relaxations. In other words, starting with a half-integral optimal solution to an LP relaxation, we assign integral values to variables one-by-one by branch and bound. This technique is general and the resulting time complexity has a low dependency on the parameter. However, the time complexity often becomes a large polynomial in the input size because we need to compute half-integral optimal LP solutions.
In this paper, we address this issue by providing an -time algorithm for solving the LPs arising from various FPT problems, where is the optimal value and is the number of edges/constraints. Our algorithm is based on interesting connections among 0/1/all constraints, which has been studied in the field of constraints satisfaction, -path packing, which has been studied in the field of combinatorial optimization, and the LPs used in FPT algorithms. With the aid of this algorithm, we obtain improved FPT algorithms for various problems, including Group Feedback Vertex Set, Subset Feedback Vertex Set, Node Multiway Cut, Node Unique Label Cover, and Non-monochromatic Cycle Transversal. The obtained running time for each of these problems is linear in the input size and has the current smallest dependency on the parameter. In particular, these algorithms are the first linear-time FPT algorithms for problems including Group Feedback Vertex Set and Non-monochromatic Cycle Transversal.
Contents
1 Introduction
1.1 FPT Algorithms using Half-Integral LP Relaxations
Parameterized complexity is the subject of studying the complexity of parameterized problems. A parameterized problem with a parameter is fixed parameter tractable (FPT) if we can solve the problem in time, where is the input size. Various parameterized problems are known to be FPT. See [8, 10] and references therein for a comprehensive list of FPT problems.
One of the motivations of studying parameterized complexity is to understand tractable subclasses of (NP-)hard problems; hence, the primary interest has been which parameterized problems admit FPT algorithms. However, from a practical point of view, the running time with respect to the input size must also be small. Indeed, linear-time FPT algorithms (i.e., FPT algorithms whose running times are linear in the input size) are proposed for several problems including Treewidth [4], Almost 2-SAT [18, 31], Feedback Vertex Set (FVS) [3], Subset FVS [21], Directed FVS [22], and Node Unique Label Cover [23]. These works focused on reducing the running time with respect to the input size, and hence dependency on the parameter is often suboptimal. For example, Subset FVS admits an FPT algorithm running in 111 hides a polynomial dependency on the input size. When focusing on reducing the part, the part is often ignored using this notation. time [19] whereas the current best linear-time FPT algorithm has time complexity [21], where is the number of edges in the input graph.
The half-integrality of the LP relaxations has recently been used to design FPT algorithms for a broad range of problems [15, 9, 20, 19, 33, 17]. To see the idea, let us consider a minimization problem whose goal is to find a solution of size , and suppose that it admits a half-integral LP relaxation222 Most of the LPs used in the FPT algorithms are not natural LP relaxations of the original problems, but are LP relaxations of rooted problems. For example, the rooted version of FVS is a problem of finding a minimum vertex subset , such that the graph obtained by removing contains no cycles reachable from a prescribed vertex . Note that the existence of a half-integral LP relaxation to the rooted problem does not imply a 2-approximability of the original problem. , that is, an LP relaxation with an optimal LP solution that only uses values in . The algorithm is based on the standard branch-and-bound framework. First, we compute a half-integral (optimal) LP solution. We can stop if all the variables have integral values or the sum of the values in the LP solution exceeds . Otherwise, we fix variables with values . We then pick an arbitrary variable with value , and branch into the case that its value is fixed to [math] and the case that its value is fixed to . This approach has several big advantages. It can be applicable to various problems just by changing the LP, and has a small time complexity with respect to parameter . For many problems including Almost 2-SAT [20], Node Multiway Cut [9], and Group FVS [19], the current smallest dependency on the parameter is indeed achieved by this approach.
A drawback of the abovementioned approach is that it is not trivial how to efficiently compute half-integral LP solutions. Iwata, Wahlström, and Yoshida [19] viewed half-integrality as a discrete relaxation. They showed that one can compute half-integral LP solutions for Almost 2-SAT and (Edge) Unique Label Cover in time linear in the input size by reducing them to the - cut problem. Moreover, they showed that we can compute LP solutions with an extremal condition, which we call the farthest condition herein (see Section 2.2 for details), in the same running time. Using farthest solutions, the LP lower bound strictly increases for each branching. Consequently, they obtained linear-time FPT algorithms for these problems.
The - cut approach unfortunately does not work well for other problems such as Group FVS, Subset FVS, Node Multiway Cut, and Node Unique Label Cover because it is essentially applicable only to edge-deletion problems333Note that edge-deletion problems are easily reducible to the corresponding vertex-deletion problems in most cases by subdividing the edges and creating copies of the original vertices. and because the auxiliary network size is generally not linear in the input size (e.g., for Subset Feedback Edge Set, the size of the network becomes ). We need to resort to solving linear programs for these problems, and hence the resulting FPT algorithms have large dependencies on the input size. Among these problems, linear-time FPT algorithms have been obtained for Node Multiway Cut [6, 18], Subset FVS [21], and Node Unique Label Cover [23] by problem-specific arguments without using LP relaxations. However, they have larger dependencies on (Table 1).
The main contribution of this study is the development of an algorithm that computes farthest half-integral solutions to those LPs in time linear in the input size. Using the connection of computing half-integral LP solutions and FPT algorithms, we obtain linear-time FPT algorithms for various problems, which are summarized in Table 1. In particular, for Subset FVS, Node Multiway Cut, and Node Unique Label Cover, we substantially improve the dependency on the parameter. For the other problems including Group FVS and Non-monochromatic Cycle Transversal, we obtain the first linear-time FPT algorithms. We note that, for every problem in the table, the part in the running time of our algorithm matches or improves the smallest known. All of these results are obtained by the same approach, i.e., the branch-and-bound framework combined with the efficient computation of half-integral LPs, which demonstrates its generality.
1.2 0/1/all Deletion and -path Packing
We consider the following problem, called 0/1/all Deletion, to establish a unified framework and provide linear-time FPT algorithms for the abovementioned problems using half-integral LP relaxations. Let be a set of variables. Each variable has an individual domain . A function on that maps each variable to a value is called an assignment for . We consider the following two types of binary constraints on , called 0/1/all constraints [7]444Precisely speaking, the permutation and two-fan constraints together with empty and complete constraints are obtained by enforcing arc-consistency on the 0/1/all constraints introduced in [7]..
Permutation constraint , where is a bijection. 2. 2.
Two-fan constraint , where and .
Let be a set of 0/1/all constraints on . We assume that contains at most one constraint for each pair of distinct variables . A constraint on in is denoted by . For a subset , we denote the set by .
0/1/all Deletion Parameter:
Input: A set of variables each of which has a domain of size at most , a set of 0/1/all constraints each of which is given as a table of size , a partial assignment for a subset , and an integer .
Question: Is there a pair of a set of at most variables and a partial assignment for such that (1) holds for every and (2) satisfies all of ?
The set in the question is called a deletion set. The task of the optimization version of this problem is to compute the size of a minimum deletion set. Various FPT problems can be expressed as 0/1/all Deletion (by using a large ). Note that for several problems, we need exponential-size domains, and hence a linear-time FPT algorithm for 0/1/all Deletion does not directly imply linear-time FPT algorithms for such problems. We show that, by giving constraints not as a table but as an oracle and by using a specialized branching strategy, we can obtain linear-time FPT algorithms even for such problems in a unified way. See Section 5.2 for details.
The primal graph for is a simple undirected graph such that an edge exists if and only if a constraint on exists. An important property of the 0/1/all constraints is that, when fixing the value of a variable to , the set of values of satisfying the constraint is either (when the constraint is a two-fan with ) or a singleton (when the constraint is a permutation with or a two-fan with and ). The latter-type implication is called a unit propagation.
When we are given a partial assignment for a subset , unit propagations occur along walks in the primal graph starting at the vertices in . If the unit propagations along two different walks starting at (possibly the same) vertices in lead to a contradiction (i.e., implicate distinct singletons for the same variable), then at least one variable on the two walks must be contained in the deletion set. The concatenation of such two walks is a walk between the vertices in (called an -walk) that is said to be conflicting (see Section 2.2 for a formal definition).
This observation provides a lower bound on the minimum size of a deletion set as follows. Suppose that a deletion set with exists, and let be the set of all conflicting -walks in the primal graph for with respect to . Then, the remaining graph cannot have a walk in (i.e., is a cover (or a hitting set) of ). Hence, the minimum size of such a cover is at most .
We now consider an LP relaxation of finding a minimum cover of the set of all conflicting -walks in , called the -covering problem: we are required to find a function minimizing the total value under the constraint that for every , where “” means the summation over the occurrences of vertices in considering the multiplicity (e.g., is summed twice if intersects twice). The dual of this LP is written down as follows, as the -packing problem: we are required to find a function maximizing the total value subject to for every , where we also consider the multiplicity of the occurrences of vertices in a walk in the summation “” (e.g., is summed twice if intersects twice).
We then propose an -time algorithm for finding a pair of a half-integral -cover and a half-integral -packing with (if exists, and otherwise correctly concluding it), where and is the running time of a certain oracle for simulating unit propagations (see Section 2.3 for the detail). Note that, by LP duality, these and are both optimal solutions to the -covering and -packing problems, respectively.
Combining our algorithm with the result in [19] (see also Theorem 1 in Section 2.2), we can obtain an FPT algorithm for 0/1/all Deletion and, hence, FPT algorithms for other various problems. Section 5 provides the detailed discussion for each specific problem.
1.3 Related Work on Half-Integral -path Packing
When contains only the permutation constraints, the integral version of the -packing problem has been studied under the name of non-returning -path packing[26, 28, 34]. This is the current most general case of tractable (integral) path packing problems. Our half-integral result suggests a conjecture that the integral packing of conflicting paths will also be tractable. We also believe that ideas behind our half-integral algorithm will be useful for obtaining a faster algorithm for integral path packing problems.
For a further special case (of non-returning -path packing), called internally disjoint555They can share terminals, but not inner vertex or edge.-path packing, the integral version of the dual covering problem coincides with Node Multiway Cut, and its LP relaxation is used in the branch-and-bound FPT algorithm [9] and a 2-approximation algorithm [14] for this problem.
Several previous works in the field of combinatorial optimization can be found as regards the half-integral version of internally disjoint -path packing. Garg et al. [14] and Pap [27, 29] found that both LPs always enjoy half-integral optimal solutions even if each non-terminal vertex has an individual integral capacity instead of . Hirai [16] and Pap [27, 29] developed algorithms for finding such half-integral optimal solutions, which both run in strongly polynomial time (i.e., the number of elementary operations performed through each algorithm does not depend on the capacity values). One makes use of a sophisticated algorithm for the submodular flow problem [13] whereas the other relies on the ellipsoid method to solve LPs whose coefficient matrices only have entries [12]. Specializing on the uncapacitated case, Babenko [1] provided an -time algorithm for finding a maximum half-integral packing, where and are the numbers of vertices and edges, respectively, and denotes the optimal value, which is at most . Our algorithm for the -packing/covering problems improves the previous best running time even against this (internally disjoint) special case.
1.4 Proof Sketch
Basically, we iteratively augment a half-integral -packing , and construct a half-integral -cover of the same size when no augmentation is possible. Since the -covering and -packing problems are the dual LPs to each other, this implies that and are optimal solutions to these problems. In the case of the maximum - flow, when we failed to find an augmenting path, we can construct a minimum - cut by taking the set of edges on the flow that separates the vertices visited by the failed search from the unvisited vertices. Similarly, we can construct a minimum half-integral -cover by taking the set of vertices on the half-integral -packing that separates visited vertices from the unvisited vertices.
We describe the idea behind our algorithm for -packing by showing a relation to computing half-integral (non-bipartite) matchings, which are often called -matchings in the field of combinatorial optimization (see [32, Chapter 30] for the basics). Although we can easily obtain a maximum half-integral matching by a reduction to maximum bipartite matching [24], we propose a different approach herein. The idea behind this approach can be used for the half-integral -packing. We focus on special half-integral matchings that consist of vertex-disjoint edges of weight and odd cycles666The number of edges in the cycle is odd. with each edge having weight . A maximum half-integral matching with this special structure is known to always exist [2]. In each step, we search for an alternating path (a path that alternately uses edges of weight [math] and and never uses the edges of weight ) from the vertices not used in the current matching. Augmentation can be categorized into three types (see Figure 1).
The first case is when we found an alternating path connecting two distinct vertices not used in the current matching. The current matching uses all the even edges in . We can augment the matching size by by taking all the odd edges and discarding all the even edges.
The second case is when we found an alternating path of length ending at a vertex on an odd cycle of length . The current matching uses all the even edges in with weight and all the edges in with weight . Thus, the size of the current matching induced by and is . We can easily augment this matching to an integral matching of size by alternately taking the edges in and .
The third case is when we found a pair of prefix-sharing alternating paths of odd length and of even length ending at the same vertex. This case corresponds to a blossom in Edmonds’ algorithm for the maximum (integral) matching problem [11]. In Edmonds’ algorithm, the alternation is applied to the common prefix and then the vertices on the cycles induced by and are shrunk. In our approach, we can augment the matching size by by applying the alternation to the common prefix, then by transforming the cycle induced by and to an odd cycle with each edge having weight .
We use a similar approach in our algorithm for -packing/covering. We focus on a special type of half-integral -packings that consist of disjoint paths in of weight , called integral paths, and wheels, which are the sums of an odd number of walks in of weight and correspond to odd cycles for matching. See Section 3.1.1 for the precise definition. Although a maximum half-integral packing with a similar special structure for a very special case of -packing, internally disjoint -path packing, is known to always exist [25], the existence of such a special solution was previously unknown for any other cases. The correctness of our algorithm provides a constructive proof of the existence.
In each step, we search for an alternating path from the vertices in not used in the current packing. As opposed to the case of computing half-integral matchings, the alternating paths may use edges contained in wheels. However, for simplicity, we ignore such a case in the explanation that follows. Roughly speaking, an alternating path is a sequence of paths , where is a path internally disjoint from any integral path and wheel for odd and is fully contained in an integral path for even . In the alternation operation, we replace the integral path containing with the path obtained by concatenating and the prefix of the integral path containing . We then replace the integral path containing with …, and so on. The definition of alternating paths is rather complicated in ensuring that each introduced path is in . However, it essentially plays the same role as that for the half-integral matching case.
Augmentation can be categorized into three types. Each of which corresponds to the one for the half-integral matching case. When we find an alternating path connecting two distinct vertices in , we can augment the -packing by by applying the alternation. When we find an alternating path ending at a vertex on a wheel that is the sum of walks in of weight , we can augment the -packing by by decomposing the wheel into integral paths and introducing a new integral path. We call these two types of alternating path as an augmenting path. When we find a pair of prefix-sharing alternating paths and ending at the same vertex (with some additional conditions), we can augment the -packing by by applying the alternation to the common prefix and then by introducing a new wheel. We call this type of a pair of alternating paths as an augmenting pair.
We need to test the membership in in constant time to achieve the linear time complexity. To this end, we exploit an observation that the algorithm only tests membership against some special walks.
To obtain linear-time FPT algorithms, we need to compute a farthest minimum half-integral -cover, which is an -cover satisfying some extremal condition, in linear time. In the existing work using the - cut approach [19], this is achieved by exploiting a structural property of all the minimum - cuts [30]. We use a different approach because we do not have the corresponding structural property for all the minimum half-integral -covers. Naively, we can find a farthest minimum half-integral -cover by at most computations of the minimum half-integral -cover. We show that we can regard the whole sequence of computations as at most computations of augmenting path/pair search by properly deciding the order of these computations using the maximum half-integral -packing. Thus, it runs in linear time in total.
Another obstacle for obtaining linear-time FPT algorithms is the existence of two-fan constraints. Because 2-SAT can be expressed as 0/1/all Deletion with and , any linear-time FPT algorithm for 0/1/all Deletion must be able to solve 2-SAT in linear time. The standard linear-time algorithm for 2-SAT uses the strongly connected component decomposition of the implication graph, and the existing linear-time FPT algorithms for Almost 2-SAT, a parameterized version of 2-SAT, also use the strongly connected component decomposition of an auxiliary network [18, 31, 19]. We cannot use this approach because the size of the auxiliary network becomes super-linear for our problems. In our algorithm, we do not use the strongly connected component decomposition, but instead use a parallel unit-propagation, which is an alternative linear-time algorithm for 2-SAT.
1.5 Comparison to Babenko’s algorithm
Because our algorithm for the -packing/covering problems improves the previous best running time even against the internally-disjoint special case, we compare our algorithm with Babenko’s algorithm to clarify the reason that we obtain such an improvement. While both the algorithms iteratively augment a packing, the approaches are completely different. The main difference is the existence of augmenting pairs and the algorithm for computing augmenting paths/pairs.
In our algorithm, we focus on packings with a special structure. Both the definition of alternating paths and the algorithm for searching augmenting paths/pairs strongly rely on this structure. While the existence of a maximum half-integral packing with the special structure was already known for internally disjoint -path packing [25], Babenko’s algorithm does not directly exploit the structure, but uses a much weaker structure. This is because his augmentation strategy does not preserve the special structure because it does not consider a notion corresponding to augmenting pairs of our algorithm.
In our algorithm, we directly compute an augmenting path/pair in time and hence we can compute a maximum packing of size in time. In contrast, in Babenko’s algorithm, an auxiliary network and its - flow are constructed from the current packing, then an -augmenting path for the standard maximum flow problem is computed. From the obtained -augmenting path, we can either augment the current packing or we can find a set of vertices that can be safely contracted to some vertex in . Because contractions occur at most time per augmentation, the running time becomes .
1.6 Organization
We introduce the notions used throughout the paper in Section 2. Section 3 shows a fast algorithm that computes a maximum half-integral -packing and transforms it into a minimum half-integral -cover. Section 4 presents a fast algorithm for computing a farthest minimum half-integral -cover. We provide linear-time FPT algorithms in Section 5 using this algorithm.
2 Definitions
2.1 Basic Notations
The multiplicity function for a multiset on the ground set is defined such that is the number of times that appears in . For two multisets and on the same ground set , we denote by the multiset such that holds for any element . For a function and a multiset on the ground set , we define . For a value , we define .
All the graphs in this study are undirected. However, we sometimes need to take care of the direction of edges. For an undirected graph , we use the symbol when we take care of the direction of the edges, i.e., for but for . For simplicity, we assume that the graphs are simple; if a graph contains multiple edges or self-loops, we can easily obtain an equivalent simple graph by subdividing the edges. For vertex , we denote the set of incident edges by . For a subset , we denote the induced subgraph by .
For an undirected graph , we define a walk in as an ordered list of vertices such that for all . The integer is called the length of the walk. We denote the first and last vertices of by and by , respectively, and we say that starts from and ends at . We denote the multisets of vertices, inner vertices, and (undirected) edges appeared in by , by , and by , respectively. For an edge , we simply use the same symbol to denote the walk . A walk is called a (simple) path if for every . A walk is called a closed walk if . A closed walk is called a (simple) cycle if and for every (which implies ). We may regard a walk as a subgraph by ignoring the direction and the multiplicity. We say that a walk is internally disjoint from a subgraph if none of the inner vertices of are in and none of the edges of are in . For a walk , we define the reversed walk as . For a walk and a walk (where ), we define the concatenation of the two walks as . The notation implicitly implies .
2.2 0/1/all Deletion and Half-Integral Relaxation
We first recall 0/1/all Deletion defined in Section 1.2. We are given a set of variables with individual domains , a set of 0/1/all constraints (permutation and two-fan constraints) that can be represented by a simple undirected graph , called the primal graph, and a partial assignment for a subset . The task is to determine whether a deletion set of at most variables exists, for which there exists an assignment for such that (1) holds for every , and (2) satisfies every constraint .
As described in Section 1.2, an important property of the 0/1/all constraints is that, when fixing the value of a variable to , the set of values of satisfying the constraint is either or a singleton . We define in the former case and define in the latter case. We extend this definition to walks in the primal graph as follows. For a walk of length zero and an element , we define . For a walk starting from and an element , we define when and when . Suppose that an assignment satisfying all the constraints exists. Then, either or holds for any walk in the primal graph.
Let be a partial assignment for a subset . For a walk with , we define , which represents the set of assignments for induced by . A walk is called a -implicational walk if and . A -implicational walk is called -conflicting if and hold. We omit the prefix/subscript if it is clear from the context. We use the following lemma.
Lemma 1**.**
For any two -implicational walks and ending at the same vertex, is -conflicting if and only if .
Proof.
We prove the lemma by induction on the length of . When the length of is zero, is conflicting if and only if . When , we consider three cases.
(Case 1) If is not implicational, must be a two-fan and . Because is implicational, we have . Therefore, we have . Because any prefix of a conflicting walk is implicational, is not conflicting. Thus, the lemma holds for this case.
(Case 2) If is implicational and is a permutation , we have and . Therefore, if and only if holds. Thus, from the induction hypothesis, the lemma holds for this case.
(Case 3) If is implicational and is a two-fan , we have , , , and . Therefore, from the induction hypothesis, is conflicting. Thus, the lemma holds for this case. ∎
For two walks and ending at the same vertex, we write if is conflicting and if is not conflicting, but both and are implicational777When at least one of or is not implicational, neither nor holds.. The abovementioned lemma implies that is an equivalence relation. This is a key property in our algorithms. Appendix B presents an alternative axiomatic definition of implicational/conflicting walks and show that any path systems admitting this key property can be expressed as the set of implicational/conflicting walks with 0/1/all constraints. We obtain the following corollaries from Lemma 1.
Corollary 1**.**
If a walk is conflicting, then is also conflicting.
Corollary 2**.**
For three implicational walks , , and ending at the same vertex, if is conflicting, then at least one of and is conflicting.
We now introduce a half-integral relaxation888Originally we should define this as an LP relaxation, but we discuss it by assuming its half integrality, which is proved via our algorithm and LP duality. of 0/1/all Deletion. Let denote the set of all -conflicting walks whose internal vertices do not intersect with 999This constraint is only for simplicity. From Corollary 2, if is conflicting for some walks and ending in , at least one of and is conflicting. Therefore, a maximum packing of conflicting walks that uses none of such walks always exists.. When and are clear from the context, we simply write to refer to . Note that from Corollary 1, we can ignore the direction of walks in . A function is called a half-integral -cover if for every . The size of is defined as . A function is called a half-integral -packing if for every vertex , it holds that . The size of is defined as . From the LP-duality, we have for any pair of half-integral -cover and half-integral -packing . Any deletion set for 0/1/all Deletion must intersect every -conflicting walk; hence is an integral -cover101010Note that the converse may not hold. For example, we have when . Therefore, is the minimum integral -cover. In contrast, may not be a deletion set. Thus, the half-integral relaxation does not always lead to a 2-approximation algorithm.. Therefore, the size of the minimum half-integral -cover provides a lower bound on the size of the minimum deletion set. For a half-integral -cover , let denote the set of vertices such that an implicational walk with ending at exists.
We can prove the following property called persistency by a careful consideration of the results in [19] (see Appendix A for a detailed discussion).
Theorem 1**.**
Let be a set of 0/1/all constraints on a variable set and be a partial assignment for a subset . For any minimum half-integral -cover , there exists a minimum deletion set containing every vertex with but avoiding every vertex in .
We say that a minimum half-integral -cover dominates a minimum half-integral -cover if holds. A minimum half-integral -cover is called farthest if there exists no minimum half-integral -cover dominating . Suppose that we have an -time algorithm for computing a farthest minimum half-integral -cover. From Theorem 1, it is not difficult to obtain an -time FPT algorithm for 0/1/all Deletion. Moreover, the base of the exponent can be improved to a constant for several special cases. We give a detailed discussion in Section 5.1.
2.3 Single-Branching Pair and Incremental-Test Oracle
As shown in Section 5.2, various important NP-hard problems can be expressed as a special case of 0/1/all Deletion. However, the domain size is often (or even for several cases, where is the number of edges/constraints). Hence, if every constraint is given as the table of size , the total size of these tables already becomes super-linear. For obtaining linear-time FPT algorithms, we use oracles instead of the explicit expression of the constraints to efficiently check whether a given walk is implicational/conflicting or not.
A pair of implicational walks ending at the same vertex is called single-branching if either forms a simple path or they can be written as and for a (possibly zero-length) path and two walks and for which forms a simple cycle that is internally disjoint from . In our algorithm, we need to test whether a given walk is implicational and whether is conflicting for a given single-branching pair . To efficiently answer these queries, we use a tuple , called an incremental-test oracle, of a set and functions , , and satisfying the following.
- •
Init .
- •
Append . Let be a function such that
[TABLE]
Then, for any walk , if and only if is implicational.
- •
Test . For any single-branching pair , if and only if is conflicting.
The running time of the incremental-test oracle is defined as the maximum running time of the three functions. In general, we can naively implement the incremental-test oracle by setting , , , and iff . We can obtain a constant-time oracle by this naive implementation for several cases including Node Multiway Cut. Meanwhile, the naive implementation takes time for several other cases including Subset Feedback Vertex Set. We will see in Section 5.2 that we can implement a constant-time oracle for these cases by exploiting the constraint that the inputs to the test function are restrited to single-branching pairs.
3 Half-Integral Packing and Covering
We prove the following theorem in this section.
Theorem 2**.**
Let be a set of 0/1/all constraints on variables and be a partial assignment for a subset . Given the primal graph of , the set , an incremental-test oracle for , and an integer , we can compute a pair of minimum half-integral -cover and maximum half-integral -packing with or correctly conclude that the size of the minimum half-integral -cover is at least in time, where is the number of constraints and is the running time of the incremental-test oracle.
Our algorithm is based on a simple augmentation strategy summarized as follows. Starting with for every , we repeatedly update a half-integral -packing that always consists of only two types of conflicting walks defined in Section 3.1.1. We search an augmenting path/pair (see Section 3.1.2) in each iteration using Algorithm 1 described in Section 3.2. If one is found, we can improve the current -packing in linear time by Lemmas 2 and 3 (Augmentation); otherwise, as shown in Section 3.3, we can naturally construct a half-integral -cover of size , which guarantees the optimality of with the aid of the LP-duality. Since each augmentation increases by at least , the number of iterations is bounded by . Algorithm 1 can be implemented in linear time by Lemma 6, which concludes Theorem 2.
3.1 Preliminaries
3.1.1 Basic -Packing
In what follows, we focus on -packings that consist of only two types of conflicting walks. One is a simple path of weight , which is called an integral path. The other is a wheel defined as follows and consists of an odd number of conflicting walks of weight .
Definition 1**.**
A pair of a simple cycle of weight and (possibly zero-length) paths of weight is called a wheel if it satisfies the following conditions (Figure 2).
is an odd positive integer. 2. 2.
For any , is a path from to (where ) that is internally disjoint from . 3. 3.
For any distinct and , and share no vertices. 4. 4.
For any , , where .
The integer is called the degree of the wheel, the cycle is called the half-integral cycle of the wheel, and the paths are called the spokes of the wheel.
Note that a wheel of degree 1 is a closed walk of weight , and a wheel of degree is a sum of simple paths of weight .
A half-integral -packing is called a basic -packing if it is a sum of integral paths and wheels such that each vertex is contained in at most one of the integral paths and the wheels. In our algorithm, a basic -packing is dealt with as a weighted graph111111The weight is naturally defined for each vertex and edge by and , respectively. so that we can efficiently update integral paths and wheels in . We denote by and the sets of vertices and (undirected) edges, respectively, that are contained in some integral path or wheel in (i.e., of positive weights), and particularly by and , the sets of those contained in some integral path or spoke in (i.e., are of weight ). A walk is called internally disjoint from if it is internally disjoint from the subgraph .
For a basic -packing , we define two functions (Forward) and (Backward) as follows (Figure 3). Let be a positive-length path contained in an integral path in . From Corollary 1, we can assume that has the same direction as . We then define paths and such that holds. For a vertex contained in a spoke in , we denote by the path from to along and by the path from to along (i.e., ). For a path contained in a spoke in in the opposite direction to , we define and (i.e., ). We omit the subscript if it is clear from the context.
3.1.2 Augmenting Path/Pair
We first define an alternating path to define our augmenting path/pair.
Definition 2**.**
For a basic -packing , a concatenation of paths is called a -alternating path if it satisfies all the following conditions.
The edges in are distinct (i.e., for every ). 2. 2.
Every vertex in that is not contained in any integral path or spoke in appears in at most once121212From the other properties of the -alternating paths, a vertex contained in an integral path or a spoke can appear twice in . Hence, may not be a path in the precise sense. (i.e., for every ). 3. 3.
. 4. 4.
Each is a path of positive length satisfying the following conditions.
- (a)
For any odd , is internally disjoint from , and no internal vertex of is in . 2. (b)
For any even , is contained in an integral path or a spoke in . In the latter case, has the opposite direction to the spoke. 5. 5.
Let us define . The following conditions are satisfied for any 131313Technically, the conditions “none of the ’s are contained in …” mean that does not admit a shortcut (e.g., if there is some with contained in , we can obtain another -alternating path , where is the path from to along the integral path or spoke). As in the case of matroid intersection, we need a shortcut-less alternating path. (see Figure 4).
- (a)
If is odd, is implicational. 2. (b)
If is even and is contained in an integral path, then , and none of the ’s are contained in for . Moreover, if , none of the ’s are contained in for . 3. (c)
If is even and is contained in a spoke, then , and none of the ’s are contained in for .
Each is called a segment of . If consists of only a single segment, it is called single-segment. A zero-length path with is considered as a -alternating path with zero segments.
We define (Tail) for a -alternating path as follows: if is odd, and if is even. Note that is always implicational. We omit the subscript if it is clear from the context.
Definition 3**.**
A -alternating path is called a -augmenting path if is odd and one of the following conditions is satisfied.
, and is conflicting. 2. 2.
is contained in a half-integral cycle, but in no spokes (i.e., ). 3. 3.
is contained in a spoke , and the following two conditions are satisfied.
- (a)
. 2. (b)
For any contained in the spoke , is contained in .
Definition 4**.**
Let and be a pair of -alternating paths ending at the same vertex. is called a -augmenting pair if it satisfies all the following conditions.
and can be written as and , respectively, for some walk such that and share no edges. 2. 2.
. 3. 3.
At least one of and is odd, and if both of and are odd, . 4. 4.
For any contained in an integral path, none of the ’s are contained in in the opposite direction. Moreover, none of the ’s are contained in in the same direction if . The symmetric condition holds for any contained in an integral path.
Note that for any -alternating path , the condition 4 is always satisfied against . Therefore, in testing the condition 4 against , we only need to test pairs such that at least one of or is not contained in the common prefix .
Using a -augmenting path/pair, we can improve a basic -packing in linear time by the following lemmas, whose proofs are given in Section 3.4.
Lemma 2**.**
Given a basic -packing and a -augmenting path, a basic -packing of size at least can be constructed in linear time.
Lemma 3**.**
Given a basic -packing and a -augmenting pair, a basic -packing of size can be constructed in linear time.
Figure 5 illustrates an example of augmentations. We use the following example which corresponds to the internally-disjoint -paths with . Every vertex has the same domain and each edge has an equality (identity permutation) constraint . An alphabet beside a vertex shows the value . Any walks starting from is implicational, and a walk is conflicting if and only if . Roughly speaking, for an augmenting path connecting two distinct vertices in (i.e., when it satisfies the condition 1 of Definition 3), we take the symmetric difference of and (Figure 5, left). For an augmenting path ending at a vertex on a wheel (i.e., when it satisfies the condition 2 or 3 of Definition 3), we take the symmetric difference and then decompose the wheel into integral paths (Figure 5, middle). For an augmenting pair with a common prefix , we take the symmetric difference of and , and then introduce a new wheel whose half-integral cycle is (Figure 5, right). In addition to this basic augmentation strategy, we need several operations in ensuring that the obtained packing is a basic -packing. See the proofs in Section 3.4 for more detail.
3.2 Finding Augmenting Path/Pair
In this subsection, we propose an algorithm for computing a -augmenting path or pair. Algorithm 1 describes a rough sketch of the algorithm. We will describe later the details of an efficient implementation using the incremental-test oracle. Note that in this subsection, we prove only the soundness of the algorithm (i.e., the algorithm never returns a path or pair which is not -augmenting). The completeness of the algorithm (i.e., the algorithm always finds a -augmenting path or pair if exists) follows from Lemma 7 proved in the next subsection.
Lemma 4**.**
Any path returned by Algorithm 1 is a -augmenting path, and any pair returned by the algorithm is a -augmenting pair.
In the algorithm, we hold two indices and for each integral path initialized as and , respectively, where is the length of ; an index for each spoke initialized as ; a set of active vertices initialized as ; and a -alternating path for each visited vertex , where we call a vertex visited if has been ever pushed into . We define boundaries as the set of vertices consisting of and for each integral path and for each spoke . We preserve the following invariants during the execution of the algorithm.
Lemma 5**.**
The following invariants hold at any iteration of Algorithm 1.
For any visited , the following holds:
- (a)
* is a -alternating path,* 2. (b)
* contains only visited vertices or boundaries, and* 3. (c)
* has an odd number of segments if and only if .* 2. 2.
For any visited and with , satisfies the condition 1 of -augmenting pairs (Definition 4). 3. 3.
For any integral path , the following holds:
- (a)
, 2. (b)
* is visited if and only if or , and* 3. (c)
for any with segments and any segment contained in , is contained in or in these directions; moreover, if holds, then holds. 4. 4.
For any spoke , the following holds:
- (a)
* is visited if and only if , and* 2. (b)
for any , all the segments of contained in are contained in .
We now prove Lemma 4 and 5. All the invariants are clearly satisfied at the beginning. In each iteration, we pick an arbitrary vertex from (line 6). From the invariant 1, is a -alternating path. We then iterate over the edges such that is implicational.
When is already visited and holds, we return a pair (line 9).
Claim 1**.**
* returned at line 9 is a -augmenting pair.*
Proof.
First, we prove , which implies that is a -alternating path. If , is either the last edge of or the last edge of an odd segment of . In the former case, holds, which is a contradiction. In the latter case, from the invariant 2 against , we have , where is the path satisfying . Because and are contained in the same integral path or spoke in the same direction, we have from the condition 13 of -alternating paths. Therefore, we have , which is a contradiction.
Next, we prove that satisfies all the conditions of the -augmenting pairs (Definition 4). Suppose that holds. Then, the vertex has already been popped from and, thus, we have , which is a contradiction. Therefore, from the invariant 2, the condition 1 is satisfied. The condition 2 is satisfied because . Meanwhile, the condition 3 is satisfied because the number of segments of is odd and because, from the invariant 1, implies that the number of segments of is even. The condition 4 follows from the invariant 3. ∎
When is not visited, we consider five cases: (Case 1) is contained in an integral path; (Case 2) is contained in a spoke; (Case 3) is contained in a half-integral cycle (but not in spokes); (Case 4) (but not in ); or (Case 5) . Note that is not contained in when is not visited. Therefore, is a -alternating path. In case 3, we return , which is a -augmenting path satisfying the condition 2 of Definition 3. In case 4, if holds, we return , which is a -augmenting path satisfying the condition 1 of Definition 3, and otherwise, we do nothing. In case 5, we set and insert into (line 31). Because holds, all the invariants are clearly preserved. Finally, we consider the remaining two cases.
(Case 1)
Let be the integral path containing and let be the index such that . Because is not visited, holds from the invariant 3. If holds, we set and insert into for each index , and then update (lines 12–15). Similarly, if holds, we set and insert into for each index , and then update (lines 16–19).
Claim 2**.**
The lines 12–19 preserve all the invariants.
Proof.
The invariants 1b, 1c, 2, 3a, 3b, and 4 are clearly preserved. Let and denote the indices before the updates. For an index , let be the segments of . If holds, we have . Therefore, both and are updated to . The same argument applies to the case of . Thus, the invariant 3c is preserved.
Finally, we prove the invariant 1a by showing that is a -alternating path for any newly visited . The conditions 1–4 of -alternating paths (Definition 2) are clearly satisfied. Consider the case of . The proof for the case of is symmetric. Let be the segments of . Because holds, the condition 13 is satisfied for . Let be a segment with contained in the same integral path . From the invariant 3c and because , is contained in , and holds. Therefore, the condition 13 is satisfied for . ∎
(Case 2)
Let be the spoke containing and let be the index such that . Because is not visited, holds from the invariant 4. If holds, we return a path (line 22); otherwise, we set and insert into for each index , and then update (lines 23–25).
Claim 3**.**
* returned at line 22 is a -augmenting path.*
Proof.
Because holds, the condition 3a of the -augment paths (Definition 3) is satisfied. From the invariant 4, for any segment of contained in the spoke , is contained in . Therefore, the condition 3b is satisfied. ∎
Claim 4**.**
Lines 23–25 preserve all the invariants.
Proof.
All the invariants, except for the 1a, are clearly preserved. We prove the invariant 1a by showing that is a -alternating path for any newly visited . The conditions 1–4 of the -alternating paths (Definition 2) are clearly satisfied. Let be the segments of . Because holds, the condition 13 is satisfied for . Let be a segment with contained in the same spoke . From the invariant 4, must be contained in . Therefore, is contained in . Thus, the condition 13 is satisfied for . ∎
Implementation Detail
We exploit the incremental-test oracle as follows to achieve the linear-time complexity. For each integral path and for each index , we precompute and . For each spoke and for each index , we precompute . These precomputations can be done in time, where is the running time of the oracle.
For each visited vertex , instead of explicitly holding , we hold (1) that represents the edge picked at line 7 in the iteration when is assigned and (2) . When the algorithm finds a -augmenting path or pair, we restore using the table of in time. For an edge , we have , which can be computed in time. For any index picked at line 13 or 23, we have , which has been precomputed. For any index picked at line 17, we have , which has been precomputed. When , we have . Thus, we can compute in time for each newly visited vertex .
Next, we show that each of the equivalence tests in the algorithm can be done in time. Let be the edge picked at line 7. First, we consider the equivalence test at line 9. If holds, we have ; otherwise, forms a single-branching pair from the invariant 2, for which we can test by asking in time. Next, we consider the equivalence test at line 12. Because forms a single-branching pair, we can test by asking . This can be done in time because has been precomputed. The same argument applies to the equivalence tests at lines 16 and 22. The equivalence test at line 29 can be done in time by asking .
Now, we have shown that can be computed in time for each visited vertex , and that all the equivalence tests can be done in time for each edge picked at line 7. Because each vertex is pushed into at most once and because each edge is processed at most twice (in both directions), we obtain the following lemma.
Lemma 6**.**
Given an -time incremental-test oracle, Algorithm 1 runs in time.
3.3 Constructing Half-Integral -Cover
In this subsection, we prove that if Algorithm 1 fails to find a -augmenting path or pair, we can construct a half-integral -cover of the same size as follows. Let and be the tables used in Algorithm 1. First, we initialize for all . For each integral path , we set and if , and set if . We set for each spoke . From the construction, we have . We show that the function is an -cover.
Lemma 7**.**
If Algorithm 1 fails to find a -augmenting path or pair, the function constructed as above is a half-integral -cover of size .
We use the following lemma to prove this lemma.
Lemma 8**.**
For any implicational walk with , the vertex is visited and holds.
Proof.
We prove the lemma by induction on the length of . For any vertex with , is visited, and holds. Therefore, the statement holds when the length of is zero. Let be an implicational walk with . From the induction hypothesis, is visited, and holds. Therefore, we have . If and is contained in a half-integral cycle but in no spokes, the algorithm returns a -augmenting path at line 27. We consider the following four cases: (Case 1) ; (Case 2) and is contained in an integral path; (Case 3) and is contained in a spoke; or (Case 4) .
(Case 1)
Consider the iteration when is picked at line 6. If is already visited, holds because, otherwise, the algorithm returns a -augmenting pair. Therefore, we have . If is not visited yet and , we have . Therefore, we have . If is not visited yet and , then becomes visited, and we have .
(Case 2)
Let be the integral path containing and let be the index such that . Consider the iteration when is picked at line 6. Let and denote the values at the beginning of this iteration (hence, and might be zero). If holds, then is already visited, and holds. If additionally holds, the algorithm returns a -augmenting pair at line 9. Therefore, we have . The same argument applies to the case of .
We now consider the remaining case that holds. Because holds, at least one of or holds. If both hold, and are both set to after this iteration. Therefore, we have , which is a contradiction. If holds, is set to after this iteration. Because , must be greater than at the end of the algorithm. Therefore, we have . The same argument applies to the case of .
(Case 3)
Let be the spoke containing and be the index such that . Consider the iteration when is picked at line 6. Let denote the value at the beginning of this iteration. If holds, then is already visited, and holds. If additionally holds, the algorithm returns a -augmenting pair at line 9. Therefore, we have .
We now consider the remaining case that holds. If holds, the algorithm returns a -augmenting path at line 22. Therefore, holds and is set to after this iteration. Because , must be greater than at the end of the algorithm. Therefore, we have .
(Case 4)
Note that in this case, must be contained in an integral path or a spoke because the vertices contained in half-integral cycles are never visited. Let be the integral path or the spoke containing and let and be the indices such that and . Because is visited, is either or , and w.l.o.g., we can assume the former case. If , then is also visited, and we have . If and is not visited, then we have , which is a contradiction. Therefore, is also visited, and we have .∎
Proof of Lemma 7.
Suppose that there exists a conflicting walk with . Because holds, is either [math] or . If , by applying Lemma 8 against , we have , which is a contradiction. If , let be the vertex with on . By splitting at , we obtain two implicational walks and such that and . Because , is contained in an integral path or a spoke . Let be the index such that and, w.l.o.g., we can assume that . If is an integral path, must be greater than because, otherwise, we have .
If the length of is zero, is either [math] or . In the latter case, is an integral path, and , which is a contradiction. Thus, we have .
If has a positive length, let . By applying Lemma 8 against , is visited, and holds. If is contained in , must be because is not visited. Therefore, we have . If is not contained in , consider the iteration when is picked at line 6. We then have because, otherwise, is set to , or the algorithm returns a -augmenting path at line 22.
We now have proved that holds. By applying the same argument to , we have . Therefore, we have , which is a contradiction. ∎
3.4 Augmentation
3.4.1 Simplification of Alternating Path
Before the proofs of Lemmas 2 and 3, we introduce a useful procedure to simplify an augmenting path/pair obtained by Algorithm 1. We first define such an operation in a formal manner and prove the validity just after the definition.
Definition 5**.**
For a basic -packing and a -alternating path with , the simplification of is defined as follows (Figure 6).
- •
A function is constructed from as follows:
- –
if is contained in an integral path , replace with an integral path ;
- –
if is contained in a spoke , replace with a spoke .
- •
A walk is defined as a concatenation of paths141414When , ..
Lemma 9**.**
For any basic -packing and any -alternating path with , the simplification of satisfies the following.
* is a basic -packing with .* 2. 2.
For any even , the following holds.
- (a)
If is contained in an integral path in , it is also contained in an integral path in . Moreover, and hold. 2. (b)
If is contained in a spoke in , it is also contained in a spoke in in the direction toward . Moreover, and hold. 3. 3.
* is a -alternating path, where is the first segment, and is the -th segment 151515When , consists of the single segment ..*
Proof.
First, we prove the first claim. When is contained in an integral path , from the condition 5b of the -alternating paths (Definition 2), holds (i.e., ). Because is internally disjoint from and , is a simple path. Thus, we can replace with the integral path . When is contained in a spoke of a wheel, from the condition 5c, holds. From the definition of the wheel (Definition 1), and are both in . As holds, we have . When the degree of the wheel is at least three, and are both in . When the degree of the wheel is one, is in . Thus, this replacement of the spoke preserves the condition for the wheel.
Next, we prove the second claim. We can observe the following for any even .
- •
If both of and are contained in the same integral path in , from the condition 5b in Definition 2, is contained in , and holds. Thus, is contained in the integral path in . If they have the same direction, is contained in , and we can write for some subpath . Then, it holds that and . If they have the opposite direction, is contained in , and we can write for some subpath . Then, it holds that and .
- •
If both and are contained in the same spoke in , from the condition 5c in Definition 2, is contained in , and holds. Thus, is contained in the spoke in . Because both of them are directed toward , we can write for some subpath . Then, it holds that and .
- •
Otherwise, the integral path or the spoke containing does not change. Thus, we have and .
Finally, we prove the third claim. Because does not contain any , the conditions 1–4 in Definition 2 are satisfied. From the second claim and the property that holds for any implicational walks and satisfying , none of the three equivalence relations appeared in the condition 13 change. As we have seen in the proof of the second claim, and hold. Therefore, for any , none of the ’s with are newly contained in or . Thus, the condition 13 is satisfied. ∎
We obtain the following corollaries from Lemma 9 by repeatedly applying the simplifying operation.
Corollary 3**.**
Given a basic -packing , a -alternating path , and an even integer , a basic -packing of the same size and a -alternating path satisfying the following conditions can be constructed in linear time.
* can be written as for some implicational path .* 2. 2.
For any even , the following holds.
- (a)
If is contained in an integral path in , it is also contained in an integral path in . Moreover, and hold. 2. (b)
If is contained in a spoke in , it is also contained in a spoke in in the direction toward . Moreover, and hold.
Corollary 4**.**
Given a basic -packing and a -alternating path , a basic -packing of the same size and a single-segment -alternating path satisfying can be constructed in linear time.
3.4.2 Augmentation by Augmenting Path
The subsection aims to prove Lemma 2.
Proof of Lemma 2.
Let be the given -augmenting path and . If , by Corollary 4, we obtain in linear time a basic -packing of the same size and a single-segment -alternating path such that and . We now show that is a -augmenting path. If satisfies the condition 1 or 2 of the -augmenting paths (Definition 3), is a -augmenting path because is still contained in or . If satisfies the condition 3, the spoke that contains in might not exist in . However, from the condition 3b, is still contained in a spoke in , which may not be identical to . By the same argument as in the proof of the second statement of Lemma 9, we have . Therefore, we have . Thus, is a -augmenting path.
We can now concentrate on the case when (Figure 7). If the condition 1 is satisfied, is a conflicting path containing no vertices in . Therefore, we can obtain a basic -packing of size by inserting the integral path . Otherwise, let be the wheel containing . W.l.o.g., we can assume that is contained in or .
If is contained in , let be the prefix subpath of to and be the suffix subpath of from (i.e., ). We have because Thus, at least one of and is in , and w.l.o.g., we can assume the former case. Then, we can obtain a basic -packing of size by decomposing the wheel into integral paths and by inserting an integral path .
If is contained in , we have . Then, we can obtain a basic -packing of size by decomposing the wheel into integral paths and by inserting an integral path . ∎
3.4.3 Augmentation by Augmenting Pair
This subsection aims to prove Lemma 3.
Intuitively, we want to augment as follows. We first simplify the common prefix of by applying Corollary 3, and then obtain a new wheel whose half-integral cycle is . However, it is not that easy. This approach does not work when or intersects with spokes or intersects with the same integral path multiple times. Therefore, we augment by gradually simplifying the augmenting pair. First, we prove the lemma against a special case.
Lemma 10**.**
Given a basic -packing and a -augmenting pair satisfying all the following conditions, a basic -packing of size can be constructed in linear time.
None of the ’s are contained in the spokes. 2. 2.
None of the integral paths contain multiple ’s. 3. 3.
One of the following two conditions is satisfied:
- (a)
* or* 2. (b)
, , and and are contained in an integral path in the opposite direction.
Proof.
When satisfies the condition 3a, we further divide the case into the following two cases: or .
If , is a single-branching pair such that . Therefore, we can obtain a basic -packing of size by introducing a new wheel of degree one.
In , let be the common prefix and let us write and . We set and if is even; otherwise, we set . We define paths and as follows (Figure 8 (a)).
- •
.
- •
for .
- •
.
- •
.
- •
for even .
- •
for odd .
We now show that these paths form a wheel. The first condition of the wheel (Definition 1) is trivially satisfied. As none of the integral paths in contain multiple ’s, the second and third conditions are satisfied. We can see that the fourth condition is satisfied as follows.
- •
.
- •
for even .
- •
for odd .
- •
.
Thus, we can obtain a basic -packing of size by removing the integral paths intersecting and by inserting the wheel of degree .
Finally, we consider the case when satisfies the condition 3b. Note that must be odd from the condition 3 of -augmenting pairs (Definition 4). Let . We define paths and as follows (Figure 8 (b)).
- •
for .
- •
.
- •
.
- •
for even .
- •
for odd .
- •
.
We now show that these paths form a wheel. The first condition of the wheel is trivially satisfied. The second and third conditions are satisfied because none of the integral paths in contain multiple ’s. We can see that the fourth condition is satisfied as follows.
- •
.
- •
for even .
- •
for odd .
- •
.
- •
.
Thus, we can obtain a basic -packing of size by removing the integral paths intersecting and by inserting the wheel of degree . ∎
Next, we provide two lemmas for weakening the assumptions in the abovementioned lemma.
Lemma 11**.**
Given a basic -packing and a -augmenting pair satisfying all the following conditions, a basic -packing of size can be constructed in linear time.
None of the ’s are contained in the spokes. 2. 2’.
Any two segments of contained in the same integral path have the same direction. 3. 3.
One of the following two conditions is satisfied:
- (a)
* or* 2. (b)
, , and and are contained in an integral path in the opposite direction.
Proof.
Note that the conditions 1 and 3 are the same as those in Lemma 10. Besides, if the condition 3b is satisfied, from the condition 5b of -alternating paths (Definition 2), the integral path containing and never contain any other segments. We call a segment of obstructive if it is contained in an integral path containing multiple segments of . If there exist no obstructive segments, the condition 2 of Lemma 10 is satisfied. Thus, we can obtain a basic -packing of size by applying Lemma 10. We repeat the following process while obstructive segments exist.
Let be the first obstructive segment and () be the next segment contained in the integral path containing . From the condition 5b of the -alternating paths (Definition 2), is contained in , and holds. We construct a basic -packing of the same size and a -augmenting pair such that the precondition of this lemma is satisfied and the number of obstructive segments strictly decreases as follows (see Figure 9).
First, we construct a basic -packing of size by removing the integral path containing and from . Observe that is a -alternating path. Then, by applying Corollary 4 against and , we obtain a basic -packing of size and a single-segment -alternating path satisfying . From the condition 5b of the -alternating path , holds. From the choice of , is internally disjoint from . Thus, we can obtain a basic -packing of size by introducing a new integral path . Let be the path from to along the integral path and let .
Finally, we prove that is a -augmenting pair satisfying the preconditions of this lemma. From the construction of and , the conditions 1–4 of the -alternating paths (Definition 2) are clearly satisfied. The condition 5b is satisfied because holds. Thus, is a -alternating path. Because holds and satisfies the precondition 3 of the lemma, is a -augmenting pair. Because no segments of are newly contained in the spokes in , the condition 1 of the lemma is satisfied. From the choice of , for any even , contains no segments from . Therefore, no two segments of are newly contained in a same integral path in . Thus, the condition 2’ is satisfied. When satisfies the condition 3a, also satisfies the condition 3a. When satisfies the condition 3b, also satisfies the condition 3b because the integral path containing and remains in . Thus, all the conditions in the lemma are satisfied.
We can find the pair by gradually increasing an index , which is not reset during the repetition, and by searching for contained in by traversing the integral path. Therefore, each edge is traversed at most once through the whole process. Thus, the total running time is linear in the graph size. ∎
Lemma 12**.**
Given a basic -packing and a -augmenting pair , either of a -augmenting path or a -augmenting pair satisfying all the following conditions can be constructed in linear time.
All the segments of , except for the last one, are contained in . 2. 2.
* can be written as for some .* 3. 3.
The common prefix of contains the common prefix of . 4. 4.
The following two conditions are satisfied for the new segments of :
- (a)
no segments in are contained in the spokes, and 2. (b)
any two segments in contained in the same integral path have the same direction.
Proof.
Initially, the conditions 2–4 are trivially satisfied. We repeat the following process, which preserves these conditions. The condition 1 is satisfied when becomes one or gets contained in .
(Case 1)
If both of and are odd, we update and . Because and share no edges and because holds, is a -augmenting pair.
(Case 2)
If is even and is odd, we update and . Because and share no edges and because holds, is a -augmenting pair.
(Case 3)
If is odd, is even, and is contained in a spoke, then we search for the nearest segment of contained in by traversing the spoke. Note that none of the other segments of are contained in from the condition 5c of the -alternating paths (Definition 2). Moreover, each segment of is fully contained in or internally disjoint from because shares no edges with . Thus, each edge is traversed at most once through the entire process, and the total running time of this part is linear in the graph size. If none of the ’s are contained in , then is a -augmenting path because is contained in the spoke, and holds. Otherwise, let be the nearest segment of contained in ; let be the path from to along the spoke; and let (Figure 10 (left)). Because holds, is a -augmenting pair. Note that this finishes the process.
(Case 4)
If is odd, is even, and is contained in an integral path, then we search for the nearest segment of or contained in by traversing the integral path. Because each edge is traversed at most twice (in two directions) through the entire process, the total running time of this part is linear in the graph size. Note that from the condition 5b of the -alternating path (Definition 2), cannot contain a segment such that has the same direction as or has the opposite direction as and holds.
If the nearest segment is such that has the same direction as or has the opposite direction as and holds, let be the path from to along the integral path and (see Figure 10 (right)). Because holds, is a -augmenting pair, and we then finish the process.
Otherwise (i.e., (a) no segments are contained in , (b) the nearest segment is that has the opposite direction as and holds, or (c) the nearest segment is that has the opposite direction as and holds), we update and . Note that in this case, from the condition 5b of the -alternating paths (Definition 2) and the condition 4 of -augmenting pairs (Definition 4), conditions (b) and (c) hold not only against the nearest segment or , but also against any segments contained in .
First, we prove that is a -alternating path. The first four conditions of the -alternating paths (Definition 2) are clearly satisfied. The condition 13 is satisfied for because holds. For checking the condition 13 against the other ’s, it suffices to show that for any segment contained in the same integral path as , it holds that , and is contained in . Let be a segment contained in . From the condition 4 of the -augmenting pairs (Definition 4), has the same direction as . Thus, is contained in . Therefore, from the condition 4 again, holds. Let be a segment contained in . As we have discussed earlier, then holds, and has the opposite direction as , implying that is contained in .
Next, we prove that is a -augmenting pair. Conditions 1 and 3 of the -augmenting pairs (Definition 4) are clearly satisfied. Because holds, the condition 2 is satisfied. For checking the condition 4, it suffices to show that (1) none of the ’s with are contained in in the same direction as ; (2) if , none of the ’s with are contained in in the opposite direction as ; (3) for any contained in an integral path, is not contained in in the same direction as ; and (4) if holds, is not contained in in the opposite direction as . All these conditions directly follow from the condition 5b of the -alternating path (Definition 2).
Finally, we prove that satisfies the conditions 2–4 of this lemma. Conditions 2 and 3 are clearly satisfied. From the condition 5b of the initial -alternating path , contains none of the new segments . Thus, if a segment in is contained in the same integral path as , it must be contained in . Therefore, it has the same direction as . ∎
Finally, we prove Lemma 3 by combining Lemmas 11 and 12.
Proof of Lemma 3.
First, we apply Lemma 12 against . If we obtain a -augmenting path, we obtain a basic -packing of size by applying Lemma 2. Otherwise, we obtain an updated -augmenting pair such that all the segments of , except for the last one, are contained in the common prefix.
Next, we apply Lemma 12 against . We finish if we obtain a -augmenting path; otherwise, we obtain an updated -augmenting pair . Let and . Then, is contained in . Note that this implies that holds for any . Moreover, also holds if is even. We have because the common prefix of contains the common prefix of and because is contained in the common prefix of . Let us assume that holds, and is odd. In this case, is contained in . Therefore, holds. Then, from the condition 3 of the -augmenting pair (Definition 4), must be even, and must be contained in the same integral path as . However, this violates the condition 5b of the -alternating path because holds. Thus, holds if is odd. We consider two cases.
If is odd or and have the same direction, let be the maximum even integer at most . We apply Corollary 3 independently against and and obtain a basic -packing of the same size and -alternating paths and . Here, holds for any , and holds. Hence, the basic -packing obtained by these two applications are the same. We then, thus, use the same symbol . Because holds, is a -augmenting pair. We now show that satisfies the conditions in Lemma 11. Because is single-segment, the third condition is satisfied. We have when is odd, and we have when is even. Therefore, from the condition 4 of Lemma 12, the first and the second conditions hold. Thus, we obtain a basic -packing of size by applying Lemma 11 against .
If is even and and have the opposite direction, let . We apply Corollary 3 against independently and and obtain a basic -packing of the same size and -alternating paths and . Here, holds for any . Hence, the basic -packings obtained by these two applications are the same. We, thus, use the same symbol . Because holds, is a -augmenting pair. We now show that satisfies the conditions in Lemma 11. Because we set , the number of segments of is two. Because holds, the first segments of and are the same. Because and have the opposite direction, the second segments of and have the opposite direction. Thus, the third condition is satisfied. Note that in this case, and are contained in an integral path and, from the condition 5b of the -alternating paths (Definition 2), the integral path containing and never contain any other segments. Moreover, because , the first and second conditions follow from the condition 4 of Lemma 12. Thus, we obtain a basic -packing of size by applying Lemma 11 against . ∎
4 Farthest Cover
This section provides an algorithm for computing a farthest minimum half-integral -cover and proves the following theorem.
Theorem 3**.**
Let be a set of 0/1/all constraints on variables and be a partial assignment for a subset . Given the primal graph of , the set , an incremental-test oracle for , and an integer , we can compute a pair of a farthest minimum half-integral -cover and a maximum half-integral -packing with or correctly conclude that the size of the minimum half-integral -cover is at least in time, where is the number of constraints, and is the running time of the incremental-test oracle.
We use the following structure of a minimum half-integral -cover.
Lemma 13**.**
The following holds for any maximum basic -packing and any minimum half-integral -cover .
* for any integral path of .* 2. 2.
* for any spoke of .*
Proof.
For a wheel , we denote the degree of by and the set of vertices contained in by . Note that is not a multiset. First, we prove that is always at least and if the equality holds, then holds for any spoke of . Let be a wheel with a half-integral cycle and spokes . We define . We then have
[TABLE]
If holds, we have and for any . Because is odd, this implies that holds for any .
We now prove the lemma. Because all the integral paths and wheels do not share any vertices, we have
[TABLE]
Therefore, and must hold for any integral path and any wheel . ∎
Fix an arbitrary maximum basic -packing. From the above lemma, for every minimum half-integral -cover , we can construct unique indices and satisfying the following.
For every integral path , , and hold. 2. 2.
For every spoke , holds.
Therefore, we obtain the following corollary.
Corollary 5**.**
A minimum half-integral -cover dominates a minimum half-integral -cover if and only if the following conditions hold.
For every integral path , holds. 2. 2.
For every spoke , holds.
We use the following operation in our algorithm. Let be an implicational walk ending at a vertex . First, we create a new vertex and introduce a constraint (along with a new edge ). We then insert into and set . We call this operation as contracting .
Lemma 14**.**
Let be an implicational walk ending at a vertex and let be the set of conflicting walks after contracting . Then, any half-integral -cover is also a half-integral -cover, and any half-integral -cover satisfying is also a half-integral -cover.
Proof.
The first claim is trivial because . We now prove the second claim. Suppose that is not a half-integral -cover. Then, there exists a walk with . Because is a half-integral -cover, must contain the edge . Therefore, we can write for some implicational walk with . We then have and , which contradicts the fact that is a half-integral -cover. ∎
We now describe the algorithm for computing a farthest minimum half-integral -cover (see Algorithm 2). We iteratively apply the contraction in the algorithm. We denote the current set of the conflicting walks by and the original set by . First, we compute a maximum basic -packing using the algorithm in Section 3. We keep and reuse the tables (, , , and ) used in the last execution of Algorithm 1, which returned NO. We process the integral paths and the spokes of one by one, whose detail will be described later, by preserving the following invariants.
Lemma 15**.**
The following invariants hold at any step of Algorithm 2.
* is a maximum basic -packing.* 2. 2.
Let be the minimum half-integral -cover constructed from the current tables as described in Section 3.3 (i.e., and hold). Then, any minimum half-integral -cover dominating is also a minimum half-integral -cover dominating . 3. 3.
For any processed integral path , there exists no minimum half-integral -cover satisfying or . 4. 4.
For any processed spoke , there exists no minimum half-integral -cover satisfying .
When all the integral paths and the spokes are processed, we return the minimum half-integral -cover constructed from the current tables. We can easily prove the correctness of the algorithm from these invariants.
Lemma 16**.**
When all the integral paths and the spokes are processed, the minimum half-integral -cover of constructed from the current tables is a farthest minimum half-integral -cover.
Proof.
From the invariants 3 and 4 and Corollary 5, is a farthest minimum half-integral -cover. Because and from the invariant 1, is also a minimum half-integral -cover. Suppose that there exists a minimum half-integral -cover dominating . Then, from the invariant 2, is a minimum half-integral -cover dominating , which contradicts the fact that is a farthest minimum half-integral -cover. ∎
We now describe how to process the integral paths and spokes. For each integral path , we first repeat the following while holds (lines 3–6). Let . We first contract the implicational path . When using the incremental-test oracle, this operation can be done in a constant time by setting , which has been precomputed. We then search for a -augmenting path or pair using Algorithm 1. Instead of searching for a -augmenting path/pair from scratch by initializing the tables, we restart the search from line 4 of Algorithm 1 by setting and reusing the current tables. If the restarted search returns NO, we keep the tables updated by the restarted search and continue the repetition. Because holds, we have after the search. If the restarted search finds a -augmenting path or pair, we rewind all the changes in this step (i.e., we restore the tables to the state before the search and remove the edge inserted by the contraction), and then exit the repetition. Note that we do not rewind the changes in the previous steps where the restarted searches returned NO.
Claim 5**.**
The restarted search can correctly compute a -augmenting path or pair if exists.
Proof.
We can virtually think as follows. Because the order of at line 3 of Algorithm 1 is arbitrary, we can choose completely the same order as the one used in the last failed search that has constructed the current tables. Note that, from the invariant 3b in Lemma 5, was not visited in the last execution. Therefore, the insertion of the edge does not affect the search at all. In the end, the execution reaches to the final iteration of the while loop with , and all the tables are completely the same as the current tables. Thus, instead of running Algorithm 1 from scratch, we can use the restarted search. ∎
Claim 6**.**
Lines 3–6 preserve all the invariants.
Proof.
Because we keep the changes only when the search fails, the invariant 1 is satisfied. The invariant 2 follows from Lemma 14 against . The invariants 3 and 4 are trivial. Note that the current integral path is still under processing. ∎
Claim 7**.**
When the repetition of lines 3–6 ends, there exists no minimum half-integral -cover satisfying .
Proof.
The repetition ends when becomes equal to or when a -augmenting path or pair is found. The former case is trivial. In the latter case, let be the set of the conflicting walks after contracting . Suppose that there exists a minimum half-integral -cover satisfying the condition in the lemma. Then, from Lemma 14, is also a half-integral -cover. In contrast, the size of the maximum half-integral -packing is strictly larger than because a -augmenting path or pair is found. Thus, we have , which is a contradiction. ∎
After repeating lines 3–6, we repeat the following while holds (lines 7–10). Let . We first contract the implicational path , and then we restart the search by setting . If the restarted search fails, we continue the repetition, and if the restarted search succeeds, we rewind all the changes in this step and exit the repetition. By the same argument as in the case of lines 3–6, all the invariants are preserved and, when the repetition ends, there exists no minimum half-integral -cover satisfying . Thus, the invariant 3 is satisfied for when we have finished processing .
Next, we repeat the following for each spoke while holds (lines 12–15). Let . We first contract the implicational path , and then restart the search by setting . We continue the repetition if the restarted search fails, and, otherwise, we rewind all the changes in this step and exit the repetition. By the same argument as in the case of integral paths, all the invariants are preserved and, when the repetition ends, there exists no minimum half-integral -cover satisfying . Thus, the invariant 4 is satisfied for when we have finished processing .
Finally, we analyze the running time of Algorithm 2. The number of inserted edges is , and the number of while loops (lines 3–6, 7–10, or 12–15) is . For each while loop, a series of the restarted searches can be regarded as a single execution of Algorithm 1, which takes time. Therefore, the total running time is . Thus, we obtain Theorem 3.
5 Linear-Time FPT Algorithms
5.1 Algorithm for 0/1/all Deletion
This section proposes an -time algorithm for 0/1/all Deletion. Our algorithm is based on the branch-and-bound algorithm in [19]. We exploit the farthest minimum half-integral -cover and parallel unit-propagation to obtain a linear-time FPT algorithm.
Let be a pair of 0/1/all constraints on a variable set and a partial-assignment on a subset . We denote by . For a variable and an element , we denote by a pair such that . We denote by a pair for a variable , where is the restriction of to . We call this operation deleting . Let for a variable . We denote by a pair such that and for . We call this operation fixing . We can obtain an incremental-test oracle for by setting for each . We can observe the following.
Lemma 17**.**
The following holds for any pair and .
* admits a deletion set of size containing if and only if admits a deletion set of size .* 2. 2.
For any half-integral -cover , the following function is a half-integral -cover: and for .
Proof.
First, we prove the first claim. For a deletion set for containing , is a deletion set for . For a deletion set for , is a deletion set for .
Next, we prove the second claim. Let be a walk in . We have if . Otherwise, visits ; therefore, we have . ∎
Lemma 18**.**
The following holds for any pair and .
* admits a deletion set of size not containing if and only if admits a deletion set of size .* 2. 2.
For any half-integral -cover , the following function is a half-integral -cover: , for , and for .
Proof.
First, we prove the first claim. Let be a deletion set for not containing . Because must contain all of , is a deletion set for of size . For a deletion set for , is a deletion set for .
Next, we prove the second claim. Let be a walk in . If , we have . If visits a vertex in , we have . Otherwise, we can write . Then, we have , and thus, we have . ∎
For a minimum half-integral -cover , we define an operation called a persistency reduction as follows. We first delete every vertex in in an arbitrary order, and then fix every vertex in in an arbitrary order161616We pick an arbitrary vertex and fix . This changes and , and we repeat the process until becomes the empty set.. Because is a half-integral -cover, for any implicational walk with and , the value depends only on . Therefore, the ordering does not affect the result and for every fixing. We denote the obtained pair by .
Lemma 19**.**
* admits a deletion set of size if and only if admits a deletion set of size .*
Proof.
From Theorem 1, there exists a minimum deletion set for such that . Therefore, from Lemma 17 and 18, the claim holds. ∎
Lemma 20**.**
For a farthest minimum half-integral -cover , the restriction of to is the unique minimum half-integral -cover.
Proof.
Let be the restriction of . Then, is a half-integral -cover because for every . Suppose that there exists a half-integral -cover with and . From Lemmas 17 and 18, the following function is a half-integral -cover: for , for , for . Then, we have . Therefore, is a minimum half-integral -cover dominating , which is a contradiction. ∎
Let be a pair with . A set of pairs is called a branching set for if it has the following property: any deletion set for is a deletion set for at least one of with . Note that any deletion set for is a deletion set for . The running time of our algorithm depends on the choice of branching sets. In general, we can use the following standard choice: pick a vertex and set . In the next section, we choose different branching sets for problem-specific improvements.
Lemma 21**.**
* for some is a branching set.*
Proof.
Let be a deletion set for , and let be a satisfying assignment for . If , is a deletion set for every . Otherwise, is a deletion set for with . ∎
We now provide a linear-time FPT algorithm for 0/1/all Deletion (Algorithm 3). We denote the size of the minimum half-integral -cover for a pair by . is a procedure that returns if and only if admits a deletion set of size at most . We prove the following.
Theorem 4**.**
Let be a pair of a set of 0/1/all constraints on a variable set and a partial assignment for a subset . We are given the primal graph of , the set , an -time incremental-test oracle for , and an integer . Under the following assumptions, Algorithm 3 correctly answers whether admits a deletion set of size at most or not in time, where is the integer in the assumption and is the number of constraints.
For any , we can choose a branching set for of size at most . 2. 2.
For any and any for a possible branching set for , we have an -time incremental-test oracle for with .
Note that for 0/1/all Deletion, we assume that each constraint is given as a table of size . Therefore, the naive implementation of the incremental-test oracle runs in a constant time. When using the naive implementation of the incremental-test oracle, the second assumption trivially holds. Thus, by using the standard choice of branching sets, the algorithm runs in time.
First, we compute a farthest minimum half-integral -cover . Because the size of is a lower bound on the size of the minimum deletion set, if holds, there exists no deletion set of size at most . Otherwise, we have . From Lemma 19, we can apply the persistency reduction and decrease by . This does not change the difference because also decreases by . We rename the reduced instance to for simplicity of the notation, and let be the primal graph of . We rename the restriction of to to . From Lemma 20, is the unique minimum half-integral -cover that maps every vertex in to and every other vertex to [math]. This part can be done in time and we can construct an incremental-test oracle for the new from the incremental-test oracle for the old .
If , we pick a vertex and return .
Claim 8**.**
* admits a deletion set of size at most if and only if admits a deletion set of size at most or admits a deletion set of size at most . Moreover, both of and hold.*
Proof.
The first claim follows from Lemma 17 and 18. We now prove the second claim.
Suppose that admits a half-integral -cover of size at most . Then, from Lemma 17, we can construct a half-integral -cover of size at most with . Therefore, is a minimum half-integral -cover with , which contradicts the uniqueness of .
Suppose that admits a half-integral -cover of size at most . Then, from Lemma 18, we can construct a half-integral -cover of size at most with . Therefore, is a minimum half-integral -cover with , which contradicts the uniqueness of . ∎
If , we choose a branching set of size at most . For each , we check whether or not by the unit-propagation (i.e., by applying Algorithm 1 against the empty packing). If there exists such , let be the set of the implicated variables (i.e., for the empty cover that always returns [math]). Let be the number of edges incident to a vertex in , and suppose that is the pair minimizing . The unit-propagation for takes only time. Hence, by running the unit-propagation for every in parallel, which is simulated in a single processor in a round-robin fashion, we can find such in time. We then set , where is the pair obtained by deleting every vertex , and go back to line 5.
Claim 9**.**
* admits a deletion set of size at most if and only if admits a deletion set of size at most .*
Proof.
Any deletion set for is also a deletion set for . Let be a deletion set for , and let be a satisfying assignment for . From the construction of , admits a satisfying assignment , and every constraint with and is a two-fan with . Therefore, an assignment such that for and for satisfies . Thus, is also a deletion set for . ∎
If for all , we return .
Claim 10**.**
* admits a deletion set of size at most if and only if at least one of admits a deletion set of size . Moreover, for every .*
Proof.
The first claim follows from the definition of the branching set. Because , we have . ∎
We now have proved the correctness of the algorithm. Finally, we analyze the running time. Let be the running time of when . We can compute a farthest minimum half-integral -cover in time. If , we branch into two cases and decreases by at least for each case. Therefore, we have . If , we search for with by the parallel unit-propagation. If there exists such , the parallel unit-propagation takes time, and decreases by . Therefore, in time, we reach to the state that either or there exists no such . In the latter case, we branch into at most cases, and decreases by at least for each case. Therefore, we have . Thus, we have .
5.2 Applications to Other Problems
Finally, we show that various NP-hard problems can be expressed as a special case of 0/1/all Deletion. Note that we use for every problem other than Node Multiway Cut. We obtain a linear-time FPT algorithm for each problem by giving an incremental-test oracle and a specialized choice of branching sets.
Node Unique Label Cover Parameter:
Input: A finite alphabet , a graph , a permutation of for every edge such that given as a table of size , and an integer .
Question: Is there a pair of set of at most vertices and assignment such that for every ?
Two-fan Deletion Parameter:
Input: A set of variables , a set of two-fan constraints on of the form given as a pair , and an integer .
Question: Is there a pair of set of at most variables and assignment satisfying every constraint ?
These two problems are special cases of 0/1/all Deletion such that the set of constraints is limited to permutation or two-fan constraints. Note that the size of the domain is not a parameter for Two-fan Deletion. The naive implementation of the incremental-test oracle for these problems runs in a constant time. Thus, we can solve Node Unique Label Cover in time. We can use the following choice of a branching set for Two-fan Deletion: pick a two-fan constraint and set . Thus, we can solve Two-fan Deletion in time.
Lemma 22**.**
* for a two-fan constraint is a branching set.*
Proof.
Let be a deletion set for and let be an assignment for satisfying . If , is a deletion set for , and if , is a deletion set for . Otherwise, at least one of or holds. is a deletion set for in the former case, while is a deletion set for in the latter case. ∎
The next two problems generalize Pseudoforest Deletion [5] in different directions, where a pseudoforest is a graph in which the number of edges is at most the number of vertices for every connected component.
A graph is called monochromatically orientable if there exists an edge orientation such that, for every vertex, all the incoming edges are monochromatic. It is known that a graph is a pseudoforest if and only if there exists an edge orientation such that, for every vertex, the number of incoming edges is at most one. Therefore, when every edge has a distinct color, a graph is monochromatically orientable if and only if it is a pseudoforest. Thus, the following problem is a generalization of Pseudoforest Deletion.
Monochromatically Orientable Deletion Parameter:
Input: An edge-colored graph and an integer .
Question: Is there a set of at most vertices such that is monochromatically orientable?
We can solve Monochromatically Orientable Deletion in time by the following reduction to Two-fan Deletion. Let be the set of colors. For each vertex , we create a variable with domain , which represents the color of the incoming edges. We create a two-fan constraint for each edge of color .
Lemma 23**.**
A graph is monochromatically orientable if and only if the corresponding set of two-fan constraints is satisfiable.
Proof.
From a monochromatic orientation of , we can construct a satisfying assignment as follows: we set for each vertex , where is the unique color of the incoming edges or an arbitrary color if has no incoming edges. From a satisfying assignment , we can construct a monochromatic orientation by orienting each edge of color so that the edge is directed toward if , and toward otherwise. ∎
Another generalization of Pseudoforest Deletion is presented as follows. For a graph and an edge , contracting is an operation deleting the edge and merging and into a new vertex . Note that this operation may create parallel edges (edges and become parallel edges) and self-loops. If has parallel edges connecting and , the operation only removes one of them, and the rest becomes self-loops.
Let be a subset of edges. A subset is called a subset feedback vertex set if has no simple cycle passing through an edge of , or equivalently, the graph obtained from by contracting every edge is a forest. Similarly, we call a subset pseudoforest deletion set if the graph obtained from by contracting every edge is a pseudoforest.
Subset Pseudoforest Deletion Parameter:
Input: A graph , a set , and an integer .
Question: Is there a set of at most vertices such that the graph obtained from by contracting every edge is a pseudoforest?
This problem can be expressed as 0/1/all Deletion as follows. Every vertex has the same domain . We introduce a two-fan constraint for every edge . We also introduce an equality (identity permutation) constraint for every edge . Let be the obtained set of constraints. If has no two-fan constraints for some , has a deletion set of size zero. Therefore, we can use the same choice of branching sets as for Two-fan Deletion. Thus, the algorithm runs in time. The correctness of the expression follows from the following lemma.
Lemma 24**.**
Let be a graph with a subset and let be the corresponding set of 0/1/all constraints. Then, the graph obtained by contracting every edge is a pseudoforest if and only if is satisfiable.
Proof.
We modify for each contraction of an edge by removing the constraint and replacing every occurrence of and by . When we obtain the graph by contracting every edge , we also obtain the set of constraints corresponding to . Because every contracted edge has the equality constraint, is satisfiable if and only if is satisfiable. From Lemma 23, is satisfiable if and only if is a pseudoforest. Therefore, is satisfiable if and only if is a pseudoforest. ∎
As mentioned in Section 1.3, Node Multiway Cut is also a special case of our problem.
Node Multiway Cut Parameter:
Input: A graph , a set of terminals , and an integer .
Question: Is there a set of size at most such that every terminal in lies in a different connected component of ?
This problem can be expressed as 0/1/all Deletion as follows. First, we split each terminal as follows to make undeletable: for each edge , we create a new vertex and replace the edge with . Let be the obtained graph. We introduce a variable with for each vertex and an equality (identity permutation) constraint for each edge . Finally, we set and . We can observe that a minimum deletion set avoiding every always exists because each vertex has degree one, and such is actually a minimum multiway cut.
Let be the obtained instance. We can construct a multiway cut of size at most by rounding up a half-integral -cover . Therefore, we have . Because the domain size is , the naive implementation of the incremental-test oracle runs in a constant time. Because any has a deletion set of size zero, we do not need branching sets. Thus, we can solve Node Multiway Cut in time.
We finally show Group Feedback Vertex Set and its applications.
Group Feedback Vertex Set Parameter:
Input: A group given as an -time oracle performing the group operation , a -labeled graph with labeling with for every , where is the unity of , and an integer .
Question: Is there a set of at most vertices such that has a consistent labeling? That is, is there a labeling such that for every ?
This problem can be expressed as 0/1/all Deletion because a function is a permutation. Note that has a consistent labeling if and only if it admits no non-zero cycles (i.e., it admits no cycle with ). In contrast to Node Unique Label Cover, the domain size is not a parameter, and each permutation is given not as a table of size , but as an -time oracle answering for given . Therefore, the naive implementation of the incremental-test oracle runs in time. We can use the following choice of a branching set: pick a vertex and set . Thus, we can solve Group Feedback Vertex Set in time.
Lemma 25**.**
* is a branching set for Group Feedback Vertex Set.*
Proof.
Let be a deletion set for , and let be an assignment for satisfying . If , is a deletion set for ; otherwise, such that is a satisfying assignment for with . ∎
Subset Feedback Vertex Set Parameter:
Input: A graph , a set , and an integer .
Question: Is there a set of at most vertices such that no cycle passes through an edge of in ?
This problem can be expressed as Group Feedback Vertex Set as follows. We use a group , where is the XOR operator (). We set for each edge and for each edge . Then, a cycle is non-zero if and only if it contains an edge in .
The group operation takes time. Therefore, the naive implementation of the incremental-test oracle takes time. We now provide a constant-time incremental-test oracle for with . We use the following implementation.
[TABLE]
For a walk , the function returns the last edge of contained in or if contains no edges in . Then, for a single-branching pair , we have the simple cycle contained in contains an edge in . Therefore, the abovementioned implementation is correct. Thus, we can solve Subset Feedback Vertex Set in time.
Non-monochromatic Cycle Transversal Parameter:
Input: An edge-colored graph and an integer .
Question: Is there a set of at most vertices such that contains no non-monochromatic cycles?
This problem can be expressed as Group Feedback Vertex Set as follows. Let be the set of colors, and let denote the color of an edge . We use the group . We set for each edge . Then, a cycle is non-zero if and only if it is non-monochromatic.
The naive implementation of the incremental-test oracle takes time. We now provide a constant-time incremental-test oracle for with . We use the following implementation.
[TABLE]
[TABLE]
Let be a walk with , and let . A suffix is called the longest monochromatic suffix of if for every and or holds. We can observe that the longest monochromatic suffix of starts from and has the color if , and the longest monochromatic suffix of forms a monochromatic cycle if . Then, for a single-branching pair , we have the simple cycle contained in is non-monochromatic none of and induces a monochromatic cycle and the longest monochromatic suffixes of and start from different vertices or have different colors . Therefore, the abovementioned implementation is correct. Thus, we can solve Non-monochromatic Cycle Transversal in time.
Appendix A Proof of Persistency
First, we review the results of [19]. Let be a set containing a special element , and let . Consider a poset on such that for every and all the other pairs with are not comparable. Let be a binary operator that returns the minimum of and if they are comparable and returns otherwise. Similarly, let be a binary operator that returns the maximum of and if they are comparable and returns otherwise. We define for a binary operator and tuples of elements , . Each index herein might have a distinct domain containing , and is an abbreviation for . A function is called -submodular if the following inequality holds for any pair of inputs :
[TABLE]
We denote the restriction of a function to the domain by .
Lemma 26** ([19]).**
For a -submodular function and a minimizer of , there exists a minimizer of such that for every with .
Lemma 27** ([19]).**
The following three functions are -submodular.
- •
For a permutation on , a function defined as
[TABLE]
- •
For elements , a function defined as
[TABLE]
- •
A function defined as
[TABLE]
Proof of Theorem 1.
Let be a function obtained by taking the sum of the following functions. Each variable here has a domain . We add the function on for each permutation constraint of . We add the function on for each two-fan constraint of . Meanwhile, we add the -ary function on for each variable , where is the degree of . Similarly for each variable , we add the -ary function on with one argument fixed to (hence it acts as a -ary function), where . Then, from Lemma 27, is -submodular.
We first observe that we can convert an input of with to a half-integral -cover with and convert a half-integral -cover to an input with . For each vertex , we denote by the value of the function for , that is, for , , where is the restriction of to , and for , . We have when .
Let be an input of with . We construct by setting for each . To see that is a (half-integral) -cover, take a -conflicting walk with . Now, consider a sequence of variables for along the walk :
[TABLE]
Let and . As the walk is -conflicting, we must have an index such that or two indices such that , , , and . In both cases, .
Next, let be a half-integral -cover. Let be the satisfying assignment for . We then define an input for as follows:
[TABLE]
We have from the construction. For every vertex with , we have for every if . Otherwise, we have for every . We have in both cases. For any vertex with , there exist no edges such that because, otherwise, there exists a -conflicting walk with , which is a contradiction. Thus, we have .
Now, we prove the claim. Let be a minimum half-integral -cover. We then construct a minimizer of with . From Lemma 26, there is a minimizer of such that for every with . From the construction above, this means the existence of the desired deletion set . ∎
Appendix B Axiomatic Model
We introduce an equivalent formulation of conflicting/implicational walks. The merit of this formulation is that checking whether a set of walks satisfies the conditions below is often easier than finding an explicit expression as 0/1/all constraints.
Definition 6**.**
A pair of (possibly infinite) sets of walks in the same graph is called nice if it satisfies the following conditions.
. 2. 2.
is closed under taking a prefix (i.e., for any walk and any prefix-subwalk of , holds). 3. 3.
For two walks ending at the same vertex, we write if and only if . The relation then becomes an equivalence relation, that is, (1) , (2) , and (3) hold for every walks ending at the same vertex. 4. 4.
For any equivalent walks ending at and any edge , if and only if .
For two walks ending at the same vertex, we write if and only if . The notations or implicitly imply that and . Note that, from the definition, always holds. However, may not hold. When is the set of all walks starting from a set of vertices , is nice if and only if is the set of non-returning -walks (cf. [25, pp. 109–111]).
Lemma 28**.**
Let be the set of all implicational walks and let be the set of all conflicting walks. Then is nice.
Proof.
Conditions 1, 2, and 4 are trivial from the definition, and we only prove Condition 3. From Lemma 1, for any two walks ending at the same vertex, if and only if holds. Therefore, is an equivalence relation. ∎
Lemma 29**.**
For any nice pair for a graph , there exist domains for , 0/1/all constraints for , and a partial assignment for some such that is exactly the set of all -conflicting walks and is exactly the set of all -implicational walks.
Proof.
For each vertex , let be the classes of equivalent walks in ending at . We denote the class containing by . Let and . For each edge , we define a subdomain and a function as follows.
For any walk ending at , if and only if . 2. 2.
For any walk , holds.
Claim 11**.**
* and are well-defined.*
Proof.
Let . We have if (by Condition 4).
Suppose that , which implies . Meanwhile, by Condition 3-(1), holds and, hence, . Thus, we have , which is a contradiction. ∎
Claim 12**.**
If holds for some class , we have , , and .
Proof.
We have because holds. Suppose that there exists a class (i.e., ).
Since , we have , implying , which is a contradiction. Therefore, we have . By the same argument, we have . Thus, the claim holds. ∎
Claim 13**.**
If holds for some class , there exist classes and such that , , for every class , and for every class .
Proof.
Let . Suppose that there exists a class such that . Because holds, we have , which is a contradiction. Therefore, we have for every class . Let . Because holds, we have . Therefore, we have .
Pick an arbitrary class . If , from Claim 12, we have , which is a contradiction. Therefore, by the same argument, we have and for every class . ∎
Now, we prove the lemma. We introduce a constraint for each edge as follows: Pick an arbitrary class . If holds, from Claim 12, the edge can be expressed as for the permutation . If holds, from Claim 13, the edge can be expressed as for some classes and . ∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] M. A. Babenko. A fast algorithm for the path 2-packing problem. Theory of Computing Systems , 46(1):59–79, 2010.
- 2[2] M. L. Balinski. Integer programming: Methods, uses, computations. Management Science , 12(3):253–313, 1965.
- 3[3] A. Becker, R. Bar-Yehuda, and D. Geiger. Randomized algorithms for the loop cutset problem. Journal of Artificial Intelligence Research , 12:219–234, 2000.
- 4[4] H. L. Bodlaender. A linear-time algorithm for finding tree-decompositions of small treewidth. SIAM Journal on Computing , 25(6):1305–1317, 2006.
- 5[5] H. L. Bodlaender, H. Ono, and Y. Otachi. A faster parameterized algorithm for pseudoforest deletion. In Proceedings of the 11th International Symposium on Parameterized and Exact Computation (IPEC 2016) , pages 7:1–7:12, 2017.
- 6[6] J. Chen, Y. Liu, and S. Lu. An improved parameterized algorithm for the minimum node multiway cut problem. Algorithmica , 55(1):1–13, 2009.
- 7[7] M. C. Cooper, D. A. Cohen, and P. G. Jeavons. Characterising tractable constraints. Artificial Intelligence , 65(2):347–361, 1994.
- 8[8] M. Cygan, F. V. Fomin, Ł. Kowalik, D. Lokshtanov, D. Marx, M. Pilipczuk, M. Pilipczuk, and S. Saurabh. Parameterized Algorithms . Springer International Publishing, 2015.
