     # Computing Tree Decompositions with Small Independence Number

The independence number of a tree decomposition is the maximum of the independence numbers of the subgraphs induced by its bags. The tree-independence number of a graph is the minimum independence number of a tree decomposition of it. Several NP-hard graph problems, like maximum weight independent set, can be solved in time n^O(k) if the input graph is given with a tree decomposition of independence number at most k. However, it was an open problem if tree-independence number could be computed or approximated in n^f(k) time, for some function f, and in particular it was not known if maximum weight independent set could be solved in polynomial time on graphs of bounded tree-independence number. In this paper, we resolve the main open problems about the computation of tree-independence number. First, we give an algorithm that given an n-vertex graph G and an integer k, in time 2^O(k^2) n^O(k) either outputs a tree decomposition of G with independence number at most 8k, or determines that the tree-independence number of G is larger than k. This implies 2^O(k^2) n^O(k) time algorithms for various problems, like maximum weight independent set, parameterized by tree-independence number k without needing the decomposition as an input. Then, we show that the exact computing of tree-independence number is para-NP-hard, in particular, that for every constant k ≥ 4 it is NP-hard to decide if a given graph has tree-independence number at most k.

06/30/2022

### Treewidth versus clique number. III. Tree-independence number of graphs with a forbidden structure

We continue the study of (tw,ω)-bounded graph classes, that is, heredita...
11/08/2021

### Tree decompositions with bounded independence number and their algorithmic applications

In 2020, Dallard, Milanič, and Štorgel initiated a systematic study of g...
01/17/2021

### On Unimodality of Independence Polynomials of Trees

An independent set in a graph is a set of pairwise non-adjacent vertices...
02/27/2013

### On Testing Whether an Embedded Bayesian Network Represents a Probability Model

Testing the validity of probabilistic models containing unmeasured (hidd...
05/26/2015

### Efficient Decomposition of Image and Mesh Graphs by Lifted Multicuts

Formulations of the Image Decomposition Problem as a Multicut Problem (M...
11/28/2020

### On Parameterized Complexity of Liquid Democracy

In liquid democracy, each voter either votes herself or delegates her vo...
11/01/2017

### Inapproximability of the independent set polynomial in the complex plane

We study the complexity of approximating the independent set polynomial ...

## 1 Introduction

Tree decompositions are among the most popular tools in graph algorithms. The crucial property of tree decompositions exploited in the majority of dynamic programming algorithms is that each bag of the decomposition can interact with an optimal solution only in a bounded number of vertices. The common measure of a tree decomposition is the width, that is, the maximum size of a bag in the decomposition (minus 1). The corresponding graph parameter is the treewidth of a graph. Many problems that are intractable on general graphs can be solved efficiently when the treewidth of a graph is bounded.

However, it is not always the size of a bag that matters. For example, suppose that every bag of the decomposition is a clique, that is, the graph is chordal. Since every independent set intersects each of the clique-bags in at most one vertex, dynamic programming still computes maximum weight independent sets in such graphs in polynomial time even if the bags could be arbitrarily large. The idea of exploiting the algorithmic and structural properties of tree decompositions where every bag is “almost” a clique or can be covered by a small number of cliques has been found useful in several applications. Berg et al. used such decompositions to design subexponential-time algorithms on geometric graph classes [DBLP:journals/siamcomp/BergBKMZ20]. Fomin and Golovach [FominG21] and Jacob et al. [DBLP:conf/iwpec/JacobP0S20] used tree decompositions where each bag is obtained from a clique by deleting at most edges or adding at most vertices, respectively.

An elegant approach to capturing such properties of tree decompositions was proposed by Dallard, Milanič, and Štorgel [dallard2022firstpaper] who introduced the notion of the tree-independence number of a graph. The independence number of a tree decomposition is the maximum of the independence numbers (that is, the maximum size of an independent set) of the subgraphs induced by its bags. The tree-independence number of a graph , denoted by , is the minimum independence number of a tree decomposition of it. In particular, the tree-independence number of a chordal graph is one, and for any graph , the value does not exceed the treewidth of (plus 1) or the independence number of .

Our main interest in tree-independence number is due to its algorithmic usefulness. Dallard et al. [dallard2022firstpaper] have shown that certain NP-hard packing problems that form a common generalization of the weighted variants of the Independent Set and Induced Matching problem can be solved in time if the input graph is given with a tree decomposition of independence number . Milanič and Rza̧żewski [milanicRzazewski2022] generalized this result to solve a variant of the packing problem in which any two of the chosen subgraphs have to be at pairwise distance at least , for even . They also obtained an algorithmic metatheorem for the problem of finding a maximum-weight sparse (bounded chromatic number) induced subgraph satisfying an arbitrary but fixed property expressible in counting monadic second-order logic ().

However, the weak spot in the algorithmic approaches of [dallard2022firstpaper, milanicRzazewski2022] is the requirement that a tree decomposition with bounded independence number is given with the input. Even for , no polynomial-time algorithm producing a tree decomposition with a constant independence number or reporting that was known prior to this work.

The work of Dallard et al. [dallard2022firstpaper] concludes with several open questions on the complexity of computing . Question 8.1 in [dallard2022firstpaper] asks whether there is a computable function such that for every positive integer there exists a polynomial-time algorithm that takes as input a graph with tree-independence number at most and computes a tree decomposition of with independence number at most .

Our first main result provides a positive answer to this question by giving a time -approximation algorithm.

###### Theorem 1.1.

There is an algorithm that, given an -vertex graph and an integer , in time either outputs a tree decomposition of with the independence number at most , or concludes that the tree-independence number of is larger than .

Pipelined with the results of Dallard et al. [dallard2022firstpaper] and of Milanič and Rza̧żewski [milanicRzazewski2022], Theorem 1.1 yields that maximum weight independent set and many other problems are polynomial-time solvable on graphs with bounded tree-independence number. This answers positively also Question 8.2 from [dallard2022firstpaper], which asked if maximum weight independent set is polynomial-time solvable on all graph classes with bounded tree-independence number.

While for the classical graph parameters treewidth and cliquewidth algorithms analogous to Theorem 1.1 are known [RobertsonS-GMXIII, DBLP:journals/jct/OumS06], our result for tree-independence number is in contrast with the situation of many other recent graph parameters, in particular mim-width [vatshelle2012new] and twin-width [DBLP:journals/jacm/BonnetKTW22], for which the questions analogous to Question 8.1 from [dallard2022firstpaper] are still open.

Theorem 1.1 is also related to the original motivation for the introduction of the tree-independence number by Dallard et al. [dallard2022firstpaper]. In 2020, Dallard et al. [DMS-WG2020, dallard2021treewidth] initiated a systematic study of -bounded graph classes, that is, hereditary graph classes in which the treewidth can only be large due to the presence of a large clique. While -bounded graph classes are known to possess some good algorithmic properties related to clique and coloring problems (see [DBLP:journals/endm/ChaplickZ17, MR4332111, DMS-WG2020, dallard2021treewidth, dallard2022firstpaper]), the extent to which this property has useful algorithmic implications for problems related to independent sets is an open problem. The connection with tree-independence number follows from Ramsey’s theorem, which implies that graph classes with bounded tree-independence number are -bounded with a polynomial binding function (see [dallard2022firstpaper]). Dallard et al. [dallard2022secondpaper] conjecture the converse, namely, that every -bounded graph class has bounded tree-independence number. Combined with Theorem 1.1 and the results from [dallard2022firstpaper, milanicRzazewski2022], the conjecture, if true, would immediately imply that the maximum weight independent set and many other problems are polynomial-time solvable on any -bounded graph class.

Then, we turn to the hardness of computing tree-independence number. First, we note that by a simple reduction that given an -vertex graph produces a -vertex graph with (see [dallard2022firstpaper], as well as Lemma 5.1), all (parameterized) hardness results for independent set translate into hardness results for tree-independence number. In particular, from the result of Lin [Lin21] it follows that constant-factor approximating tree-independence number is W-hard, and from the result of Chalermsook, Cygan, Kortsarz, Laekhanukit, Manurangsi, Nanongkai, and Trevisan [DBLP:journals/siamcomp/ChalermsookCKLM20] it follows that assuming Gap-ETH, there is no time -approximation algorithm for tree-independence number for any computable functions and . In particular, the time complexity obtained in Theorem 1.1 is optimal in the sense that an factor is unavoidable assuming Gap-ETH, even if the approximation ratio would be drastically weakened.

Our second main result is para-NP-hardness of exact computing of tree-independence number. In particular, Question 8.3 from [dallard2022firstpaper] asks about the complexity of recognizing graphs with tree-independence numbers at most for a fixed integer .000There is a linear-time algorithm for deciding if a given graph has tree-independence number at most , because such graphs are exactly the chordal graphs, see, e.g., [Golumbic80]. While for values and the question remains open, we resolve it for any constant .

###### Theorem 1.2.

For every constant , it is NP-complete to decide whether for a given graph .

Theorem 1.2 implies also that assuming , there is no time approximation algorithm for tree-independence number with approximation ratio less than .

We supplement our main results with a second NP-completeness proof on a problem closely related to tree-independence number and the algorithm of Theorem 1.1. We consider the problem where we are given a graph , two nonadjacent vertices and , and an integer , and the task is to decide if and can be separated by removing a set of vertices that induces a subgraph with independence number at most . We show that this problem is NP-complete for any fixed integer . This hardness result is motivated by the fact that the algorithm of Theorem 1.1 finds separators with bounded independence number as a subroutine. While for the algorithm of Theorem 1.1 we design a time 2-approximation algorithm for a generalization of this problem, assuming that a tree decomposition of independence number is given, this proof shows that this step of the algorithm cannot be turned into exact (in our reduction we can construct along the graph also a tree decomposition of independence number of ).

We supplement our results also with an observation that tree-independence number is the most general parameter that is “naturally” defined over tree decompositions and that yields slicewise polynomial-time algorithms for independent set. In particular, let be a parameter that is defined like the tree-independence number , but instead of using the independence number using some other graph invariant satisfying for any graph and vertex . We show that then, either independent set is para-NP-hard parameterized by , or can be upper-bounded as a function of .

The rest of this paper is organized as follows. In Section 2, we overview the proofs of our main results, Theorem 1.1 and Theorem 1.2. In Section 3 we recall definitions and preliminary results. Section 4 is devoted to the proof of Theorem 1.1 and Section 5 to the proof of Theorem 1.2. In Section 6 we show the NP-hardness of finding separators with bounded independence number and in Section 7 we give the argument about the generality of tree-independence number.

## 2 Overview

In this section we sketch the proofs of our two main results, Theorem 1.1 and Theorem 1.2.

### 2.1 Outline of the algorithm

For simplicity, we sketch here a version of Theorem 1.1 with approximation ratio 11 instead of 8. The difference between the 11-approximation and 8-approximation is that for 11-approximation it is sufficient to use 2-way separators, while for 8-approximation we use 3-way separators.

On a high level, our algorithm follows the classical technique of constructing a tree decomposition by repeatedly finding balanced separators. This technique was introduced by Robertson and Seymour in Graph Minors XIII [RobertsonS-GMXIII], was used for example in [DBLP:journals/siamcomp/BodlaenderDDFLP16, DBLP:journals/siamcomp/BergBKMZ20, DBLP:conf/iwpec/JacobP0S20], and an exposition of it was given in [cygan2015parameterized, Section 7.6.2].

The challenge in applying this technique is the need to compute separators that are both balanced and small with respect to the independence numbers of the involved vertex sets. Our main technical contribution is an approximation algorithm for finding such separators. In what follows, we will sketch an algorithm that given a graph , a parameter , and a set of vertices with independence number either finds a partition of such that each , , and are nonempty, separates from , , and for both , or determines that the tree-independence number of is larger than . (For we use to denote the independence number of the induced subgraph .) Our algorithm for finding such balanced separators works in two parts. First, we reduce finding balanced separators to finding separators, and then we give a 2-approximation algorithm for finding separators.

At first glance, it is not even clear that small tree-independence number guarantees the existence of such balanced separators. To prove the existence of balanced separators and to reduce the finding of balanced separators to finding separators between specified sets of vertices, instead of directly enforcing that both sides of the separation have a small independence number, we enforce that both sides of the separation have sufficiently large independence number. More precisely, we pick an arbitrary independent set of size . By making use of the properties of tree decompositions, it is possible to show that there exists a separation with for and . Hence for . By enforcing the condition for both , we will have that for both . (Note that .) Therefore, to find a balanced separator for (or to conclude that the tree-independence number of is larger than ), it is sufficient to select an arbitrary independent set with , do guesses for sets and , and for each of the guesses search for a separator between the sets and .

In the separator finding algorithm the input includes two sets and , and the task is to find a set of vertices disjoint from both and separating from with or to conclude that no such separator with

exists. Our algorithm works by first using multiple stages of different branching steps, and then arriving at a special case which is solved by rounding a linear program. We explain some details in what follows.

First, by using iterative compression around the whole algorithm, we can assume that we have a tree decomposition with independence number available. We show that any set with can be covered by bags of the tree decomposition. This implies that by first guessing the covering bags, we reduce the problem to the case where we search for a separator for some set with independence number .

Then, we use a branching procedure to reduce the problem to the case where . In the branching, we select a vertex , and branch into three subproblems, corresponding to including into , into , or into a partially constructed solution . The key observation here is that if we branch on vertices , then the branches where is included in or in reduce the value . By first handling the case with by branching on vertices at the same time and then branching on single vertices, this branching results in instances where .

Finally, when we arrive at the subproblem where , we design a -approximation algorithm by rounding a linear program. For , let us have variables with indicating that and indicating that . Because , the fact that separates from can be encoded by only using inequalities of form . To bound the independence number of , for every independent set of size we add a constraint that . Now, a separator with corresponds to an integer solution. We then find a fractional solution and round to if and to otherwise. Note that this satisfies the constraints, so the rounded solution corresponds to a separator. To bound the independence number of the rounded solution, note that for independent sets of size , therefore implying that .

### 2.2 Outline of the Np-hardness proof

We explain the general idea of the reduction behind Theorem 1.2 in a somewhat inversed order, in particular by making a sequence of observations about a particular special case of the problem of determining if , culminating in observing that it corresponds to 3-coloring.

Let be a graph that does not contain cliques of size four. We create a graph by first taking the disjoint union of two copies and of the complement , and then adding a matching between and by connecting the corresponding copies of the vertices. Then, we enforce that the sets and are bags in any tree decomposition of of independence number at most 4 by adding 5 vertices with and 5 vertices with . Now, the problem of determining whether boils down to determining if we can construct a path decomposition with independence number at most with a bag on one end and a bag on the other end (the additional vertices and can be immediately ignored after the bags and have been enforced).

The problem of constructing such a path decomposition corresponds to the problem of finding an ordering according to which the vertices in should be eliminated when traversing the decomposition from the bag of to the bag of . In particular, because the edges between and are a matching, we can assume that in an optimal path decomposition a vertex of is introduced right before the corresponding vertex in is eliminated. From the viewpoint of the original graph , this problem now corresponds to finding an ordering of so that for every it holds that , where denotes the size of the largest clique of a graph. This problem in turn corresponds to determining if has two disjoint subsets such that for both it holds that the vertex cover number of is at most 1, and intersects every triangle of . This problem is very closely related to 3-coloring, in particular if instead of having vertex cover number at most 1 we would ask to be an independent set and if every edge of would be contained in a triangle, this problem in fact would be equivalent to 3-coloring. Indeed, we show a reduction from 3-coloring to this problem, which finishes the NP-hardness proof.

## 3 Preliminaries

We denote the vertex set and the edge set of a graph by and , respectively. The neighborhood of a vertex in is the set of vertices adjacent to in , and the closed neighborhood of is the set . These concepts are extended to sets such that is defined as the union of all closed neighborhoods of vertices in , and is defined as the set . The degree of , denoted by , is the cardinality of the set . When there is no ambiguity, we may omit the subscript in the notations of the degree, and open and closed neighborhoods, and thus simply write , , and , respectively.

Given a set , we denote by the subgraph of induced by . We also write . Similarly, given a vertex , we denote by the graph obtained from by deleting . The complement of a graph is the graph with vertex set in which two distinct vertices are adjacent if and only if they are nonadjacent in . For a positive integer , we denote the -vertex complete graph, path, and cycle by , , and respectively. For positive integers and we denote by the complete bipartite graph with parts of sizes and . A graph is chordal if it has no induced cycles of length at least four.

A clique (resp. independent set) in a graph is a set of pairwise adjacent (resp. nonadjacent) vertices. The independence number of , denoted by , is the maximum size of an independent set in . For a set of vertices , the independence number of is .

Let be a tuple of disjoint subsets of . A -separator is a set such that for each , and in the graph there is no path from to for all pairs . Such a separator is sometimes called a -way separator. Note that if is adjacent to for some , then no -separator exists.

A tree decomposition of a graph is a pair where is a tree and every node of is assigned a vertex subset called a bag such that the following conditions are satisfied: (1) every vertex of is in at least one bag, (2) for every edge there exists a node such that contains both and , and (3) for every vertex the subgraph of induced by the set is connected (that is, a tree). The independence number of a tree decomposition of a graph , denoted by , is defined as follows:

 α(T)=maxt∈V(T)α(Xt).

The tree-independence number of , denoted by , is the minimum independence number among all tree decompositions of .

## 4 An 8-approximation algorithm for tree-independence number

In this section we prove Theorem 1.1, that is, we give a time algorithm for either computing tree decompositions with independence number at most or deciding that the tree-independence number of the graph is more than . Our algorithm consists of three parts. First, we give a time 2-approximation algorithm for finding 3-way separators with independence number at most , with the assumption that a tree decomposition with independence number is given with the input. Then, we apply this separator finding algorithm to find balanced separators, and then apply balanced separators in the fashion of the Robertson-Seymour treewidth approximation algorithm [RobertsonS-GMXIII] to construct a tree decomposition with an independence number at most . The requirement for having a tree decomposition with independence number as an input in the separator algorithm is satisfied by iterative compression (see, e.g., [cygan2015parameterized]), as we explain at the end of Section 4.3.

The presentation of the algorithm in this section is in reverse order compared to the presentation we give in Section 2.1.

### 4.1 Finding approximate separators

In this subsection, we show the following theorem.

###### Theorem 4.1.

There is an algorithm, that given a graph , an integer , a tree decomposition of with independence number , and three disjoint sets of vertices , in time either reports that no -separator with independence number at most exists, or returns a -separator with independence number at most .

To prove Theorem 4.1, we define a more general problem that we call partial -way -separator, which is the same as the problem of Theorem 4.1 except that two sets and are given with the input, and we are only looking for separators with .

###### Definition 4.1 (Partial 3-way α-separator).

An instance of partial 3-way -separator is a 5-tuple , where is a graph, , and are disjoint subsets of , and is an integer. A solution to partial 3-way -separator is a -separator such that . A -approximation algorithm for partial 3-way -separator either returns a solution with or determines that there is no solution with .

We give a 2-approximation algorithm for partial 3-way -separator. Then Theorem 4.1 will follow by setting and .

We give our 2-approximation algorithm by giving 2-approximation algorithms for increasingly more general cases of partial 3-way -separator. First, we give a linear programming based 2-approximation algorithm for the special case when . Then, we use branching and the first algorithm to give a 2-approximation algorithm for the case when . Then, we use the input tree decomposition to reduce the general case to the case where .

Let us make some observations about trivial instances of partial 3-way -separator. First, we can assume that , as otherwise any solution has and we can return no immediately. All our algorithms include an factor in the time complexity, so it can be assumed that this condition is always tested. Then, we can also always return no if is adjacent to , where . This can be checked in polynomial time, so we can assume that this condition is always tested. Note that testing this condition implies that . We prefer to write as it is shorter.

We start with the linear programming based 2-approximation algorithm for the case when .

###### Lemma 4.1.

There is an time -approximation algorithm for partial -way -separator when .

###### Proof.

First, note that we may assume that for all , , there is no path in the graph between a vertex of and a vertex of , since otherwise the given instance has no solution at all. Furthermore, under this assumption, we can safely replace each set with the set of vertices reachable from a vertex in in the graph . We thus arrive at an instance such that . We then make an integer programming formulation of the problem (with constraints) and show that it gives a 2-approximation by rounding a fractional solution.

For every vertex we introduce a variable , with the interpretation that if and otherwise. We force to be in the solution by adding constraints for all . Then, we say that a pair of vertices with , , , is connected if there is a -path in the graph . For any pair of connected vertices we introduce a constraint indicating that or should be selected to the solution. Note that here it can happen that , corresponding to the case when , resulting in a constraint forcing to be in the solution. Finally, for every independent set of size , we introduce a constraint .

We observe that any solution with corresponds to a solution to the integer program. In particular, any -separator must satisfy the constraints for connected pairs , as otherwise there would be a ,-path in , and a separator with satisfies the independent set constraints as otherwise it would contain an independent set larger than .

Then, we show that any integral solution that satisfies the constraints for connected pairs and the constraints for corresponds to a -separator. Suppose that all such constraints are satisfied by an integral solution corresponding to a set , but there is a path from to with in . Take a shortest path connecting to in for any , and note that the intermediate vertices of such path do not intersect , as otherwise we could get a shorter path, and therefore do not intersect . By , we have that the intermediate vertices do not intersect , so this path is in fact a path in the graph , where is the first vertex and is the last vertex. However, in this case is a connected pair and we have a constraint , which would be violated by such an integral solution, so we get a contradiction.

We solve the linear program in polynomial time (which is as the number of variables is and the number of constraints is ), and round the solution by rounding to 1 if and otherwise to 0. This rounding will satisfy the constraints for connected pairs, so the resulting solution corresponds to a separator. Then, by the constraints for independent sets of size , the rounded solution will satisfy for independent sets of size . Therefore, there are no independent sets of size in the resulting solution, so its independence number is at most . ∎

We will pipeline 4.1 with branching to obtain a 2-approximation algorithm for partial 3-way -separator in a setting where is small. In our final algorithm, will be bounded by , and this is the part that causes the factor in the time complexity.

Let us observe that we can naturally branch on vertices in in instances of partial 3-way -separator.

###### Lemma 4.2 (Branching).

Let be an instance of partial 3-way -separator, and let . If is a solution of , then is also a solution of at least one of

1. ,

2. ,

3. , or

4. .

Moreover, any solution of any of the instances 1-4 is also a solution of .

###### Proof.

If is a solution of , we can partition to parts , , and by including the vertices in any connected component of containing vertices of into for all , and including the vertices in connected components containing no vertices of into , resulting in a partition of such that is a -separator. Therefore, the first branch corresponds to when , the second when , the third when , and the fourth when .

The direction that any solution of any of the instances 1-4 is also a solution of the original instance is immediate from the fact that we do not remove vertices from any or . ∎

4.2 allows to branch into four subproblems, corresponding to the situation whether a vertex from goes to , , , or to . Now, our goal is to branch until we derive an instance with , which can be solved by 4.1. In particular, we would like to branch on vertices . The following lemma shows that we can use as a measure of progress in the branching.

###### Lemma 4.3.

For any vertex it holds that .

###### Proof.

If , then we could take an independent set such that and construct an independent set of size , which is a contradiction. ∎

4.3 means that when branching on a vertex , the branches where is moved to , , or decrease . This will be the main idea of our algorithm for the case when is bounded, which we give next.

###### Lemma 4.4.

There is a time -approximation algorithm for partial 3-way -separator.

###### Proof.

We give a branching algorithm, whose base case is the case when , which is solved by 4.1. The main idea is to analyze the branching by the invariant , in particular with corresponding to the base case. The branching itself will be “exact” in the sense that all four cases of 4.2 are always included, in particular, the 2-approximation is caused only by the application of 4.1.

First, while , which can be checked in time, we branch as follows. We select an independent set of size , and for all of its vertices we branch on whether to move it into , , , or , i.e., according to 4.2. Because is an independent set, at most of the vertices can go to , so at least go to , , or . Also for the reason that is an independent set, 4.3 can be successively applied for all of the vertices that go to , , or . Therefore, this decreases by at least , so the depth of this recursion is at most , so the total number of nodes in this branching tree is at most .

Then, we can assume that . We continue with a similar branching, this time branching on single vertices. In particular, as long as is nonempty, we select a vertex in it and branch on whether to move it into , , , or . To analyze the size of this branching tree, note that by 4.3, when moving a vertex into , , or , the value of decreases by at least one. Therefore, as initially , any root-to-leaf path of the branching tree contains less than edges that correspond to such branches, and therefore any root-leaf path can be characterized by specifying the indices corresponding to such edges, and then for these indices whether they correspond to , , or . The length of any root-leaf path is at most because decreases in every branch, and therefore the number of different root-to-leaf paths is at most , and therefore the total number of nodes in this branching tree is .

Therefore, the total size of both of the branching trees put together is , so our algorithm works by applications of 4.1, resulting in a time algorithm. ∎

Finally, what is left is to reduce the general case to the case where . We do not know if this can be done in general, but we manage to do it by using a tree decomposition with independence number . To this end, we show the following lemma. Given a graph , a tree decomposition of , and a set , we say that is covered by a set of bags of if every vertex in is contained in at least one of the bags in . The lemma generalizes the well-known fact that any clique of , that is, a set with , is covered by a single bag of the tree decomposition.

###### Lemma 4.5.

Let be a graph, a tree decomposition of , and a nonempty set of vertices of . Then is covered by a set of at most bags of .

###### Proof.

We denote . Every edge corresponds to a partition of , where is the set of vertices of in the bags of that are closer to than , is the set of vertices of in the bags of that are closer to than , and is a -separator.

First, suppose that for every edge either or . If both , then , and we cover by a single bag (or ). Thus suppose that for every edge exactly one of the sets and is nonempty. We orient the edge from towards if , and from to if . Because is a tree, there exists a node such that all edges incident with are oriented towards . This implies that covers because otherwise some edge would be oriented away from .

Note that if , then is a clique and indeed for every edge either or . The remaining case is that and that there exists an edge such that both and hold. In this case, we use induction on . Since is a -separator, we have that . Therefore we can take the union of a smallest set of bags covering , a smallest set of bags covering , and the bag . By induction, this set of bags covering contains at most bags. ∎

With 4.5, we can use a tree decomposition with independence number to 2-approximate the general case of partial 3-way -separator as follows. By 4.5, any solution with is covered by at most bags of . Therefore, with available (and having bags by standard arguments), we can guess the set of at most bags of that covers , and intersect by the union of these bags, resulting in . Therefore, we solve the general case by applications of 4.4 with , resulting in a total time complexity of . This completes the proof of Theorem 4.1.

### 4.2 From separators to balanced separators

In this subsection we show that Theorem 4.1 can be used to either find certain balanced separators for sets or to show that the tree-independence number of the graph is large.

To enforce the “balance” condition, we cannot directly enforce that the separator separates a given set into sets of small independence numbers. (This would result in time complexity exponential in instead of .) Instead, we fix a maximum independent set in , and enforce that this independent set is separated in a balanced manner. As long as this independent set is large enough, this will enforce that the separator is balanced also with respect to . The following lemma, which is an adaptation of a well-known lemma given in Graph Minors II [DBLP:journals/jal/RobertsonS86] is the starting point of this approach.

###### Lemma 4.6.

Let be a graph with tree-independence number at most and an independent set. Then there exists a partition of (where some can be empty) such that is a -separator, , and for any pair with .

###### Proof.

Let be a tree decomposition of with . As in Lemma 4.5, we introduce the following notation. Every edge of corresponds to a partition of , where is the set of vertices of in the bags of that are closer to than , is the set of vertices of in the bags of that are closer to than , and is a -separator. We orient the edge from to if , from to if , and otherwise arbitrarily. Now, because is a tree, there exists a node such that all of its incident edges are oriented towards it. Therefore, for all connected components of , we see that , as otherwise some edge would be oriented out of .

As long as the number of such connected components is at least 4, we can take two of them with the smallest values of and merge them, in the end arriving at a partition of such that is a -separator, , and for all . Then, because , we have that . Therefore, since , it follows that , where is any permutation of the set . ∎

Next we use 4.6 together with the separator algorithm of Theorem 4.1 to design an algorithm for finding -balanced separators of sets with .

###### Lemma 4.7.

There is an algorithm that for a given graph , an integer , a tree decomposition of with independence number , and a set with , in time either concludes that the tree-independence number of is larger than , or finds a partition of such that is a -separator, , at most one of , , and is empty, and for each