Composing dynamic programming tree-decomposition-based algorithms

TL;DR

This paper introduces a method to compose dynamic programming algorithms for complex graph partitioning problems based on recognizing simpler graph classes, leading to efficient algorithms for various problems.

Contribution

It provides a constructive way to build dynamic programming algorithms for partitioning problems from algorithms recognizing individual graph classes.

Findings

Applicable to well-known problems like Vertex Cover and Graph Coloring

Improves algorithms for bioinformatics problem DISPLAYGRAPH

Achieves running times comparable or better than existing algorithms

Abstract

Given two integers $\ell$ and $p$ as well as $\ell$ graph classes $\mathcal{H}_1,\ldots,\mathcal{H}_\ell$, the problems $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, \break $\mathsf{VertPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$, and $\mathsf{EdgePart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$ ask, given graph $G$ as input, whether $V(G)$, $V(G)$, $E(G)$ respectively can be partitioned into $\ell$ sets $S_1, \ldots, S_\ell$ such that, for each $i$ between $1$ and $\ell$, $G[S_i] \in \mathcal{H}_i$, $G[S_i] \in \mathcal{H}_i$, $(V(G),S_i) \in \mathcal{H}_i$ respectively. Moreover in $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, we request that the number of edges with endpoints in different sets of the partition is bounded by $p$. We show that if there exist dynamic programming tree-decomposition-based algorithms for recognizing the graph classes $\mathcal{H}_i$, for each $i$, then we can constructively create a dynamic programming tree-decomposition-based algorithms for $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, $\mathsf{VertPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$, and $\mathsf{EdgePart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$. We apply this approach to known problems. For well-studied problems, like VERTEX COVER and GRAPH $q$-COLORING, we obtain running times that are comparable to those of the best known problem-specific algorithms. For an exotic problem from bioinformatics, called DISPLAYGRAPH, this approach improves the known algorithm parameterized by treewidth.

Equations

$${\mathsf{Accept}}_{\mathfrak{C},G,\mathcal{D}}$$

$${\mathsf{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)$$

$${\tau }_n(\mathfrak{C},G,\mathcal{D},t)$$

$$\begin{array}{ll}\text{if child(t)=∅,}& \alpha (t)\\ \text{if child(t)={t′},}& (\alpha (t),\alpha (t^{\prime }))\\ \text{if child(t)={t′,t′′},}& (\alpha (t),\alpha (t^{\prime }),\alpha (t^{\prime \prime }))\end{array}\}$$

$${\mathsf{Accept}}_{\mathfrak{C}}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},0}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},1}(G,G^{\prime })$$

$${\mathsf{Process}}_{\mathfrak{C},2}(G,G^{\prime },G^{\prime \prime })$$

$${\mathsf{Accept}}_{\mathfrak{C}}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},0}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},1}(G,G^{\prime })$$

$${\mathsf{Process}}_{\mathfrak{C},2}(G,G^{\prime },G^{\prime \prime })$$

$${\mathsf{Accept}}_{\mathfrak{C}}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},0}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},1}(G,G^{\prime })$$

$$\forall i\in \left[1,\ell \right],(m_i,m_i^{\prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,1}(G,G^{\prime })\},$$

$${\mathsf{Process}}_{\mathfrak{C},2}(G,G^{\prime },G^{\prime \prime })$$

$$\forall i\in \left[1,\ell \right],(m_i,m_i^{\prime },m_i^{\prime \prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,2}(G,G^{\prime },G^{\prime \prime })\}.$$

$${\tau }_g(\mathfrak{C},G,\mathcal{D})=\sum _{i\in \left[1,\ell \right]}{\tau }_g({\mathfrak{C}}_i,G,\mathcal{D})+\mathcal{O}\left(\sum _{t\in V(T)}|{\mathsf{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)|\right).$$

$${\mathsf{Accept}}_{\mathfrak{C}}(G)$$

$${\mathsf{Process}}_{\mathfrak{C},0}(G)$$

$$\exists i\in \left[1,\ell \right],m_i\in {\mathsf{Process}}_{{\mathfrak{C}}_i,0}(G)$$

$$\forall j\in \left[1,\ell \right]\setminus \{i\},m_j=\perp \},$$

$${\mathsf{Process}}_{\mathfrak{C},1}(G,G^{\prime })$$

$$\exists i\in \left[1,\ell \right],(m_i,m_i^{\prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,1}(G,G^{\prime })$$

$$\forall j\in \left[1,\ell \right]\setminus \{i\},(m_j,m_j^{\prime })=(\perp ,\perp )\},and$$

$${\mathsf{Process}}_{\mathfrak{C},2}(G,G^{\prime },G^{\prime \prime })$$

$$\forall i\in \left[1,\ell \right],(m_i,m_i^{\prime },m_i^{\prime \prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,2}(G,G^{\prime },G^{\prime \prime })$$

$$\forall j\in \left[1,\ell \right]\setminus \{i\},(m_j,m_j^{\prime },m_j^{\prime \prime })=(\perp ,\perp ,\perp )\}.$$

$${\mathsf{Accept}}_{\mathfrak{C}}(G)$$

$$q\le p,$$

$$V_1,\dots ,V_{\ell }\text{ is a partition of V(G), and }$$

$$\forall i\in \left[1,\ell \right],m_i\in {\mathsf{Accept}}_{{\mathfrak{C}}_i}(G[V_i])\},$$

$${\mathsf{Process}}_{\mathfrak{C},0}(G)$$

$$V_1,\dots ,V_{\ell }\text{ is a partition of V(G) and }$$

$$\forall i\in \left[1,\ell \right],m_i\in {\mathsf{Process}}_{{\mathfrak{C}}_i,0}(G[V_i])\},$$

$${\mathsf{Process}}_{\mathfrak{C},1}(G,G^{\prime })$$

$$U_1,\dots ,U_{\ell }\text{ is a partition of V(G)∪V(G′), }$$

$$\forall i\in \left[1,\ell \right],V_i=U_i\cap V(G),$$

$$\forall i\in \left[1,\ell \right],V_i^{\prime }=U_i\cap V(G^{\prime }),$$

$$\forall i\in \left[1,\ell \right],(m_i,m_i^{\prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,1}(G[V_i],G^{\prime }[V_i^{\prime }]),$$

$$q\le p,\text{ and}$$

$$q=q^{\prime }+\sum _{i\in \left[1,\ell \right]}|{\mathsf{edge}}_G(U_i\setminus V(G),(V(G)\cup V(G^{\prime }))\setminus U_i)|\},$$

$${\mathsf{Process}}_{\mathfrak{C},2}(G,G^{\prime },G^{\prime \prime })$$

$$((m_1^{\prime \prime },V_1^{\prime \prime }),\dots ,(m_{\ell }^{\prime \prime },V_{\ell }^{\prime \prime }),q^{\prime \prime }))\mid$$

$$U_1,\dots ,U_{\ell }\text{ is a partition of V(G)∪V(G′)∪V(G′′), }$$

$$\forall i\in \left[1,\ell \right],V_i=U_i\cap V(G),$$

$$\forall i\in \left[1,\ell \right],V_i^{\prime }=U_i\cap V(G^{\prime }),$$

$$\forall i\in \left[1,\ell \right],V_i^{\prime \prime }=U_i\cap V(G^{\prime \prime }),$$

$$\forall i\in \left[1,\ell \right],(m_i,m_i^{\prime },m_i^{\prime \prime })\in {\mathsf{Process}}_{{\mathfrak{C}}_i,2}(G[V_i],G^{\prime }[V_i^{\prime }],G^{\prime \prime }[V_i^{\prime \prime }]),$$

$$q\le p,\text{ and}$$

Full text

Keywords: graph partition; treewidth; parameterized complexity; dynamic programming; dynamic programming core model.

1 Introduction

In one of the first graph partition problems, one is asked, given a graph $G$ and an integer $k$, whether $V(G)$ can be partitioned into $\ell$ sets $V_{1},\ldots,V_{\ell}$ such that the number of edges between two different sets is small, see for instance [9]. These problems have many applications starting from clustering genes [21], through optimizing financial problems [15], parallel scientific computing to image segmentation [10, 23], and analysis of social networks [16]. The above specified graph partitioning problem favors cutting small sets of isolated vertices in the input graph [22, 24]. In order to avoid this kind of solution which is often undesirable for many practical applications, restrictions are often imposed on the sets $V_{i}$, $i\in\left[1,\ell\right]$. The most natural restriction is to require the partition to be balanced [1]. Another one, used in image segmentation, is to consider normalized cuts [22], that is, cuts that maximize the similarity within the sets while minimizing the dissimilarity between the sets. In social networks, the graph clustering problem is a graph partition problem where the graphs $G[V_{i}]$, $i\in\left[1,\ell\right]$, are required to be dense [19]. In this paper, we consider the graph partition problem in a general form defined in the following way. Given $\ell$ graph classes $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ and an integer $p$, the $\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$ problem consists in, given a graph $G$, determining whether $V(G)$ can be partitioned into $\ell$ sets $V_{1},\ldots,V_{\ell}$ such that $\{\{u,v\}\in E(G)\mid u\in V_{i},v\in V_{j},i\not=j\}$, i.e., the set of transversal edges, is of size at most $p$ and $G[V_{i}]\in\mathcal{H}_{i}$ for each $i\in\left[1,\ell\right]$.

Coloring problems are special kinds of graph partition problems where the number of transversal edges is not relevant anymore. So, in the $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ problem, the task is to determine whether the vertex set of the input graph $G$ can be partitioned into $\ell$ sets $V_{1},\ldots,V_{\ell}$ such that $G[V_{i}]\in\mathcal{H}_{i}$ for each $i\in\left[1,\ell\right]$. The most famous coloring problem is the Graph $3$-Colorability problem corresponding to $\mathsf{VertPart}(\mathcal{I},\mathcal{I},\mathcal{I})$ where $\mathcal{I}$ is the class of edgeless graphs. This problem is one of the first problems proved by Karp to be NP-hard [13] and has attracted a lot of attention. While Graph $3$-Colorability is the best known, several other graph classes are also under study. For instance, in [25, 17, 27], the authors consider the induced matching partition where each vertex set of the partition should induce a graph of maximum degree $1$. In [6], the authors focus on $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ where $\ell$ is a fixed integer, $\mathcal{H}_{1}=\ldots=\mathcal{H}_{\ell}=\mathcal{R}$, and $\mathcal{R}$ is either the class of every tree or the class of every forest. These problems are called Tree Arboricity when $\mathcal{R}$ is the class of every tree and Vertex Arboricity when $\mathcal{R}$ is the class of every forest. They provide polynomial time algorithms for block-cactus graph, series-parallel graphs, and cographs. In [26], the authors focus on planar graphs of diameter two. These problems have in particular applications in bioinformatics for constructing phylogenetic trees [12].

The treewidth of a graph is a structural parameter that measures the similarity of the graph to a forest, see Section 2 for the formal definitions. Courcelle [7] shows that every problem that can be expressed in monadic second-order logic can be solved in FPT-time parameterized by treewidth, i.e., in time $f({\sf{tw}})\cdot n^{\mathcal{O}(1)}$ for some function $f$ where $n$ (resp. ${\sf{tw}}$) denotes the number of vertices (resp. the treewidth) of the input graph. In [18], the author shows that if there is a monadic second-order logic formula that recognizes a graph class $\mathcal{H}$, then for any fixed integer $\ell$, $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$, with $\mathcal{H}_{i}=\mathcal{H}$ for all $i\in\left[1,\ell\right]$, can be solved in polynomial time on graphs of bounded treewidth. If [7] and [18] provide powerful meta-algorithms, the claimed running times may be far from being optimal. For instance, Courcelle theorem [7] provides an $2^{2^{\mathcal{O}({\sf{tw}})}}\cdot n^{\mathcal{O}(1)}$ algorithm for Graph $3$-Coloring when it is well known that an $2^{{\mathcal{O}({\sf{tw}})}}\cdot n^{\mathcal{O}(1)}$ algorithm exists, see for instance [8, Theorem 7.9].

Recently, treewidth has found several applications in bioinformatics when dealing with the so-called display graphs [5, 20, 3]. In [12], in order to solve the DisplayGraph problem, the authors are interested in determining whether a given graph of bounded treewidth is a positive instance of $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$ where $\mathcal{T}$ is the class of all trees. Using Courcelle’s theorem, they provide a $2^{2^{\mathcal{O}({\sf{tw}})}}\cdot n^{\mathcal{O}(1)}$ algorithm. Using the approach developed in this paper, we obtain, as Corollary 14, an algorithm running in time $2^{\mathcal{O}({\sf{tw}})}\cdot n^{\mathcal{O}(1)}$ for this same problem.

The dynamic programming core model is a formalism introduced in [2]. It was first introduced in order to construct meta-algorithms for what are called diverse problems. It provides a formalism for dynamic programming algorithms that process a tree decomposition, once, in a bottom-up approach. This kind of algorithm is indeed widely used when working with treewidth. Therefore the dynamic programming core model allows us to manipulate most of the known algorithms that process a tree decomposition.

In the present paper, we use the expressive power of this formalism and show that, with some enhancement, it can be used to easily provide algorithms, with good running times, that solve the graph partition problems parameterized by treewidth. Roughly speaking, given $\ell$ graph classes $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$, we show that solving $\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$ or $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ is not much harder than recognizing each $\mathcal{H}_{i}$, using a dynamic programming tree-decomposition-based algorithm. Moreover, we provide, in Theorem 10 and Theorem 11, the explicit running time needed for solving $\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$ and $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ respectively as a function of the running time needed for recognizing each $\mathcal{H}_{i}$. We provide, in Theorem 12, similar result for the case where we want to partition the edge set of the graph, that is, for the graph problem $\mathsf{EdgePart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ that, given a graph $G$, consists in determining whether $E(G)$ can be partitioned into $\ell$ sets $S_{1},\ldots,S_{\ell}$ such that $(V(G),S_{i})\in\mathcal{H}_{i}$ for each $i\in\left[1,\ell\right]$.

The main feature of our contribution is to present a meta-approach that provides easy-to-build and efficient algorithms for exotic problems. Moreover the running time obtained for known problems are comparable to the best-known algorithms specifically designed for each given known problem.

In Section 2, we introduce the notations and useful definitions. Section 3 is devoted to the definition of the dynamic programming core model together with some examples of dynamic cores. The main results are given in Section 4. In Section 5, we show how these results can be applied to reproduce known results and to provide unknown algorithms for exotic problems. We provide a short conclusion in Section 6.

2 Preliminaries

We denote by $\mathbb{N}$ the set of nonnegative integers. Given two integers $a$ and $b$ we define $\left[a,b\right]$ the set of every integer $c$ such that $a\leq c\leq b$. Let $G$ be a graph. Let $\ell$ be an integer and $A=(m_{1},\ldots,m_{\ell})$ be a $\ell$-tuple. For each $i\in\left[1,\ell\right]$, we use the notation $A.(i)$ to refer to the $i$-th coordinate of $A$, i.e., in this case to $m_{i}$. Note that the coordinates are numbered from $1$ to $\ell$. Given a set $S$, we denote by $2^{S}$ the set of every subset of $S$. Given an alphabet $\Sigma$, we denote by $\mathcal{W}_{\Sigma}$ the set of every finite words over $\Sigma$. We denote by $\Gamma$ the set of three special letters denoted “(”, “)”, and “,”.

We use $V(G)$ and $E(G)$ to denote the vertex and edge sets, respectively, of the graph $G$. Through out this paper, we assume that vertices are represented as elements of $\mathbb{N}$. Given a set $S\subseteq V(G)$, we denote by $G[S]$ the subgraph of $G$ induced by $S$. Given a set $S\subseteq E(G)$, we denote by $G[S]$ the graph $(V(G),S)$. Given two sets $S_{1},S_{2}\subseteq V(G)$, we denote by $\mathsf{edge}_{G}(S_{1},S_{2})$ the set of every edge of $G$ with one endpoint in $S_{1}$ and the other endpoint in $S_{2}$. We also denote by $\mathcal{G}$ the set of every graph. We denote by $\mathcal{I}$ the class of edgeless graphs. Given an integer $p$, we denote by $\mathcal{G}_{p}$ the class of every graph with at most $p$ vertices. We also denote by $\mathcal{T}$ the set of every tree and by $\mathcal{F}$ the set of every forest. Given a tree $T$ rooted at $r$, for each $t\in V(T)$, we denote by $\mathsf{child}(t)$ the set of every child of $t$ in $T$ and by $\mathsf{desc}(t)$ the set of every descendent of $t$ in $T$.

A rooted tree decomposition of a graph $G$ is a tuple ${\cal D}=(T,r,{\cal X})$, where $T$ is a tree rooted at $r\in V(T)$ and ${\cal X}=\{X_{t}\mid t\in V(T)\}$ is a collection of subsets of $V(G)$ such that:

• •

$\bigcup_{t\in V(T)}X_{t}=V(G)$,

• •

for every edge $\{u,v\}\in E$, there is a $t\in V(T)$ such that $\{u,v\}\subseteq X_{t}$, and

• •

for each $\{x,y,z\}\subseteq V(T)$ such that $z$ lies on the unique path between $x$ and $y$ in $T$, $X_{x}\cap X_{y}\subseteq X_{z}$.

The width of a tree decomposition ${\cal D}=(T,r,{\cal X})$, denoted by ${\sf{w}}(\mathcal{D})$, is defined as $\max_{t\in V(T)}|X_{t}|-1$. The treewidth of a graph $G$, denoted by ${\sf{tw}}(G)$, is the smallest integer $w$ such that there exists a tree decomposition of $G$ of width at most $w$. We also define $Y_{t}=X_{t}\cup\bigcup_{t^{\prime}\in\mathsf{child}(t)}X_{t^{\prime}}$ and $Z_{t}=X_{t}\cup\bigcup_{t^{\prime}\in\mathsf{desc}(t)}X_{t^{\prime}}$.

It is well known, see for instance [14], that given a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$, we can, without loss of generality, assume that $X_{r}=\emptyset$, that, for each $t\in V(T)$, $t$ has at most $2$ children and that $|Y_{t}|\leq|X_{t}|+1$. In the following we always assume that the rooted tree decompositions have these properties.

Given a graph $G$, a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and a set $S\subseteq V(G)$, we define $\mathcal{D}[S]$ to be $(T,r,\{X_{t}\cap S\mid t\in V(T)\})$. Note that $\mathcal{D}[S]$ is a rooted tree decomposition of $G[S]$.

3 Dynamic programming core model

In this section we define and use an improvement of the dynamic programming core model introduced in [2]. The main idea of this model is to formalize what is a dynamic programming algorithm based on a tree decomposition. This will allow us to manipulate these algorithms in their generic form in order to construct meta-algorithms.

Definition 1** (Dynamic Core).**

A dynamic core $\mathfrak{C}$ over an alphabet $\Sigma$ is a set of four functions:

• •

$\mathsf{Accept}_{\mathfrak{C}}:\mathcal{G}\to 2^{\mathcal{W}_{\Sigma}}$,

• •

$\mathsf{Process}_{\mathfrak{C},0}:\mathcal{G}\to 2^{\mathcal{W}_{\Sigma}}$,

• •

$\mathsf{Process}_{\mathfrak{C},1}:\mathcal{G}\times\mathcal{G}\to 2^{\mathcal{W}_{\Sigma}^{2}}$, and

• •

$\mathsf{Process}_{\mathfrak{C},2}:\mathcal{G}\times\mathcal{G}\times\mathcal{G}\to 2^{\mathcal{W}_{\Sigma}^{3}}$.

In the following, we always assume that the associated alphabet is implicitly given when a dynamic core is mentioned and we denote by $\Sigma_{\mathfrak{C}}$ the alphabet associated to a dynamic core $\mathfrak{C}$. Given a dynamic core $\mathfrak{C}$, a graph $G$ and a rooted tree decomposition $\mathcal{D}=(T,r,{\cal X})$ of $G$, the data of $\mathfrak{C}$ associated to $(G,\mathcal{D})$ are, for each $t\in V(T)$:

[TABLE]

We would like to highlight that Definition 1 is the main addition of this paper, concerning the definition of the dynamic programming core model, compared to [2]. The functions $\mathsf{Process}_{\mathfrak{C},0}$, $\mathsf{Process}_{\mathfrak{C},1}$, and $\mathsf{Process}_{\mathfrak{C},2}$ can be viewed as the rules to update the table of the given dynamic programming algorithm, and so allow to easily and naturally construct a dynamic core from a dynamic programming algorithm that is based on a tree decomposition. Note that these rules are given independently of the tree decomposition as it is usual to do for a dynamic programming algorithm. The definitions of $\mathsf{Accept}_{\mathfrak{C},G,\mathcal{D}}$ and $\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}$, if we consider $\Sigma=\{0,1\}$, are equivalent to the ones initially defined in [2].

Note that, in this work, we assume that $X_{r}=\emptyset$ and so $\mathsf{Accept}_{\mathfrak{C},G,\mathcal{D}}=\mathsf{Accept}_{\mathfrak{C}}((\emptyset,\emptyset))$. We still keep the general notation, with $X_{r}$, to keep the setting as flexible as possible. Given a function $f:\mathcal{K}\to\mathcal{J}$ and an input $I\in\mathcal{K}$, we denote by $\tau(f,I)$ the time needed to compute $f(I)$. Given a dynamic core $\mathfrak{C}$, a graph $G$ and a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ we let:

[TABLE]

We also define $\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{t\in V(T)}\tau_{n}(\mathfrak{C},G,\mathcal{D},t)$ and $\mathsf{size}(\mathfrak{C},G,\mathcal{D},t)=\max_{A\subseteq Y_{t}}|\mathsf{Process}_{\mathfrak{C},G[A],\mathcal{D}[A]}(t)|$. The $n$ of $\tau_{n}$ stands for node, and the $g$ of $\tau_{g}$ stands for global. Note that, for each $t\in V(T)$, $\mathsf{Process}_{\mathfrak{C},G[Y_{t}],\mathcal{D}[Y_{t}]}(t)=\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$. We say that a dynamic core $\mathfrak{C}$ is polynomial, if for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$, $\mathsf{size}(\mathfrak{C},G,\mathcal{D},t)$ and $\tau_{n}(\mathfrak{C},G,\mathcal{D},t)$ are polynomial in $|V(G)|+|V(T)|$.

Definition 2**.**

Let $\mathfrak{C}$ be a dynamic core, $G$ be a graph in $\mathcal{G}$, and $\mathcal{D}=(T,r,\mathcal{X})$ be a rooted tree decomposition of $G$. A $(\mathfrak{C},G,\mathcal{D})$-witness is a function $\alpha:V(T)\rightarrow\Sigma_{\mathfrak{C}}^{*}$ such that $\alpha(r)\in\mathsf{Accept}_{\mathfrak{C},G,\mathcal{D}}$ and for each $t\in V(T)$,

[TABLE]

The witness provided in Definition 2 can be seen as a proof of the correctness of the algorithms we can produce using a given dynamic core.

Definition 3**.**

Let $\mathcal{H}$ be a class of graphs. We say that a dynamic core $\mathfrak{C}$ solves $\mathcal{H}$ if for each graph $G\in\mathcal{G}$, and each rooted tree decomposition $\mathcal{D}$ of $G$, $G\in\mathcal{H}$ if and only if a $(\mathfrak{C},G,\mathcal{D})$-witness exists.

As explained in [2] and summarized in Theorem 4, a dynamic core can be seen as an algorithm producer. Moreover the running time of the produced algorithms is directly connected to the definition of the associated dynamic core.

Theorem 4** ([2]).**

Let $\mathcal{H}$ be a class of graphs and $\mathfrak{C}$ be a dynamic core that solves $\mathcal{H}$. Given a graph $G\in\mathcal{G}$ and a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, one can decide whether $G\in\mathcal{H}$ in time $\mathcal{O}\left(\sum_{t\in V(T)}|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|+\tau_{g}(\mathfrak{C},G,\mathcal{D})\right)$.

3.1 Some examples of dynamic core

In this section we provide a few examples of dynamic cores. We start by a trivial dynamic core that allows us to produce an algorithm that recognizes that a graph has no edge. This dynamic core solves $\mathcal{I}$, the class of graphs with no edges.

Observation 5**.**

$\mathcal{I}$* can be solved by a polynomial dynamic core $\mathfrak{C}$.*

Proof.

We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

In this case, $\Sigma_{\mathfrak{C}}=\{\top\}$ where $\top$ represents the fact that the already explored part does not contain any edge. Given $G\in\mathcal{I}$ and $\mathcal{D}=(T,r,\mathcal{X})$ a rooted tree decomposition of $G$, a $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha$ is such that, for each $t\in V(T)$, $\alpha(t)=\top$.

For the running time, note that given a graph $G$ and a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, then for each $t\in V(T)$, $|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq 1$ and $\tau_{n}(\mathfrak{C},G,\mathcal{D},t)=\mathcal{O}(|X_{t}|)$. ∎

We also provide a slightly more involved dynamic core that solves $\mathcal{G}_{p}$ for some integer $p$, i.e, the class of graphs with at most $p$ vertices.

Observation 6**.**

Let $p$ be an integer. $\mathcal{G}_{p}$ can be solved by a polynomial dynamic core $\mathfrak{C}$.

Proof.

We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

It is now an easy task to show that $\mathfrak{C}$ solves $\mathcal{G}_{p}$. In this case, given a graph $G\in\mathcal{G}_{p}$ and a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$, a possible $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha$ is such that, for each $t\in V(T)$, $\alpha(t)=|Z_{t}\setminus X_{t}|$. Simply note that we only count the number of vertices in the part that has already been completely explored and forgotten and that $X_{r}=\emptyset$.

For the running time, note that given a graph $G$ and a rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, then, for each $t\in V(T)$, $|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq(p+1)^{2}$ and $\tau_{n}(\mathfrak{C},G,\mathcal{D},t)=\mathcal{O}(|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|)$. The lemma follows. ∎

Observations 5 and 6 show how to construct a dynamic core for trivially solvable problems. We mostly provided these observations as pedagogical examples. One can then get the intuition that most of the dynamic programming algorithms parameterized by treewidth can be translated into dynamic cores. Indeed, such an algorithm creates a dynamic programming table for each node of the tree decomposition. Theses tables are updated depending of dynamic programming tables of the children of the node taken into consideration. Transposing how these updates are done into a consistent definition of $\mathsf{Process}_{\mathfrak{C},0}$, $\mathsf{Process}_{\mathfrak{C},1}$, or $\mathsf{Process}_{\mathfrak{C},2}$, depending on the number of children of the node taken in consideration, will then provide a dynamic core for the problem.

The rank-based approach [4] provides, in particular, a deterministic algorithm that solves Feedback Vertex Set in time $2^{\mathcal{O}({\sf{tw}})}\cdot n^{\mathcal{O}(1)}$, where $n$ (resp. ${\sf{tw}}$) stands for the size (resp. treewidth) of the input graph. From this algorithm, one can easily obtain a dynamic core for recognizing if a graph is a tree. We omit the proof of it as it requires to reintroduce several tools presented in [4] that are out of the scope of this paper.

Observation 7**.**

The class $\mathcal{T}$ of trees can be solved by a dynamic core $\mathfrak{C}$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|=2^{\mathcal{O}({\sf{w}}(\mathcal{D}))}\cdot n^{\mathcal{O}(1)}$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=2^{\mathcal{O}({\sf{w}}(\mathcal{D}))}\cdot|V(T)|\cdot n^{\mathcal{O}(1)}$**

Note in particular that the dynamic core provided in Observation 7 is not polynomial.

3.2 Union and intersection of dynamic core

In this section we provide some simple combinations of dynamic cores. More precisely, we show how to take the union and the intersection of two dynamic cores. This will allow us, in Theorems 10, 11, and 12, to consider the union (resp. intersection) of recognizable classes without having to prove each time that the considered union (resp. intersection) is recognizable. Let $\mathcal{H}_{1}$ and $\mathcal{H}_{2}$ be two graph classes and let $\mathfrak{C}_{1}$ (resp. $\mathfrak{C}_{2}$) be a dynamic core that solves $\mathcal{H}_{1}$ (resp. $\mathcal{H}_{2}$). We would like to stress that, in order to solve $\mathcal{H}_{1}\cup\mathcal{H}_{2}$ or $\mathcal{H}_{1}\cap\mathcal{H}_{2}$, the naive procedure, consisting of using $\mathfrak{C}_{1}$ and then using $\mathfrak{C}_{2}$, would be more efficient with regard to the running time but will not produce a dynamic core. As the main theorems of the paper, namely Theorems 10, 11, and 12, rely on the knowledge of a dynamic core, this naive procedure will not suit.

Lemma 8**.**

Let $\ell$ be an integer, let $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ be graph classes and let, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ be a dynamic core that solves $\mathcal{H}_{i}$. There exists a dynamic core $\mathfrak{C}$ that solves $\mathcal{H}=\bigcap_{i\in\left[1,\ell\right]}\mathcal{H}_{i}$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|=\prod_{i\in\left[1,\ell\right]}|\mathsf{Process}_{\mathfrak{C}_{i},G,\mathcal{D}}(t)|$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{i\in\left[1,\ell\right]}\tau_{g}(\mathfrak{C}_{i},G,\mathcal{D})+\mathcal{O}\left(\sum_{t\in V(T)}|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\right)$**

Proof.

We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

We now prove that $\mathfrak{C}$ solves $\mathcal{H}$. First note that $\Sigma_{\mathfrak{C}}=\Gamma\cup\bigcup_{i\in\left[1,\ell\right]}\Sigma_{\mathfrak{C}_{i}}$. Let $G$ be a graph and $\mathcal{D}=(T,r,\mathcal{X})$ be a rooted tree decomposition of $G$.

Assume first that $G\in\mathcal{H}$, then by definition of $\mathcal{H}$, for each $i\in\left[1,\ell\right]$, $G\in\mathcal{H}_{i}$. Let, for each $i\in\left[1,\ell\right]$, $\alpha_{i}:V(T)\to\Sigma^{*}_{\mathfrak{C}_{i}}$ be a $(\mathfrak{C}_{i},G,\mathcal{D})$-witness. Note that it exists as $\mathfrak{C}_{i}$ solves $\mathcal{H}_{i}$ and $G\in\mathcal{H}_{i}$. We define $\alpha:V(T)\to\Sigma^{*}_{\mathfrak{C}}$ such that for each $t\in V(T)$, $\alpha(t)=(\alpha_{1}(t),\ldots,\alpha_{\ell}(t))$. By construction of $\mathfrak{C}$, $\alpha$ is a $(\mathfrak{C},G,\mathcal{D})$-witness.

Assume now that there exists a $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha:V(T)\to\Sigma^{*}_{\mathfrak{C}}$. Then by definition of $\mathfrak{C}$, for each $t\in V(T)$, $\alpha(t)$ is a $\ell$-tuple. Let define $\ell$ functions $\alpha_{i}:V(T)\to\Sigma^{*}_{\mathfrak{C}}$, $i\in\left[1,\ell\right]$, such that for each $i\in\left[1,\ell\right]$ and each $t\in V(T)$, $\alpha_{i}(t)=\alpha(t).(i)$. Then, by definition of $\mathfrak{C}$, for each $i\in\left[1,\ell\right]$, $\alpha_{i}$ is a $(\mathfrak{C}_{i},G,\mathcal{D})$-witness and so $G\in\mathcal{H}_{i}$. Thus $G\in\mathcal{H}$.

Let us now analyze the needed running time for this algorithm. Let $G$ be a graph and $\mathcal{D}=(T,r,\mathcal{X})$ be a rooted tree decomposition of $G$. For each $t\in V(T)$, we have, by definition, $|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|=\prod_{i\in\left[1,\ell\right]}|\mathsf{Process}_{\mathfrak{C}_{i},G,\mathcal{D}}(t)|$. In order to construct the data of $\mathfrak{C}$ associated to $(G,\mathcal{D})$, we need first to construct the data of $\mathfrak{C}_{i}$ associated to $(G,\mathcal{D})$ for each $i\in\left[1,\ell\right]$ and then to combine them. Thus, we have

[TABLE]

∎

Lemma 9**.**

Let $\ell$ be an integer, let $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ be graph classes and let, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ be a dynamic core that solves $\mathcal{H}_{i}$. There exists a dynamic core $\mathfrak{C}$ that solves $\mathcal{H}=\bigcup_{i\in\left[1,\ell\right]}\mathcal{H}_{i}$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|=\sum_{i\in\left[1,\ell\right]}|\mathsf{Process}_{\mathfrak{C}_{i},G,\mathcal{D}}(t)|$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{i\in\left[1,\ell\right]}\tau_{g}(\mathfrak{C}_{i},G,\mathcal{D})+\mathcal{O}\left(\sum_{t\in V(T)}|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\right)$**

Proof.

Let $\bot$ be an unused letter. We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

We prove, using the same kind of argumentation as for Theorem 8, that $\mathfrak{C}$ solves $\mathcal{H}$. Note that in this case, the letter $\bot$ is used, in particular, for each coordinate $i$ such that $G\not\in\mathcal{H}_{i}$. ∎

4 Main theorem

In this section we show, given two integers $\ell$ and $p$, $\ell$ graph classes $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ and $\ell$ dynamic cores $\mathfrak{C}_{1},\ldots,\mathfrak{C}_{\ell}$ such that, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ solves $\mathcal{H}_{i}$, how to construct dynamic cores that solve $\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$, $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$, and $\mathsf{EdgePart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$.

We start by the graph partition problem, that is the most involved case.

Theorem 10**.**

Let $\ell$ and $p$ be two integers, let $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ be graph classes and let, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ be a dynamic core that solves $\mathcal{H}_{i}$. There exists a dynamic core $\mathfrak{C}$ that solves $\mathcal{H}=\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq\ell^{|Y_{t}|}\cdot(p+1)^{2}\cdot\prod_{i\in\left[1,\ell\right]}\mathsf{size}(\mathfrak{C}_{i},G,\mathcal{D},t)$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{t\in V(T)}\left(\mathcal{O}(|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|)+2^{|Y_{t}|}\cdot\sum_{i\in\left[1,\ell\right]}\tau_{n}(\mathfrak{C}_{i},G,\mathcal{D},t)\right)$**

Proof.

We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

We now prove that $\mathfrak{C}$ solves $\mathcal{H}=\mathsf{GraphPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell},p)$. First note that $\Sigma_{\mathfrak{C}}=\Gamma\cup\mathbb{N}\cup\bigcup_{i\in\left[1,\ell\right]}\Sigma_{\mathfrak{C}_{i}}$. Let $G$ be a graph and $\mathcal{D}=(T,r,\mathcal{X})$ be a rooted tree decomposition of $G$.

Assume first that $G\in\mathcal{H}$. Then, by definition, there exists $V_{1},\ldots,V_{\ell}$, partition of $V(G)$ such that for each $i\in\left[1,\ell\right]$, $G[V_{i}]\in\mathcal{H}_{i}$ and $\sum_{1\leq i<j\leq\ell}|\mathsf{edge}_{G}(V_{i},V_{j})|\leq p$. As, for each $i\in\left[1,\ell\right]$, $\mathcal{D}[V_{i}]$ is a rooted tree decomposition of $G[V_{i}]$ and $G[V_{i}]\in\mathcal{H}_{i}$, there exists $\alpha_{i}:V(T)\to\Sigma^{*}_{\mathfrak{C}_{i}}$, a $(\mathfrak{C}_{i},G[V_{i}],\mathcal{D}[V_{i}])$-witness. Note that this witness exists as $G[V_{i}]\in\mathcal{H}_{i}$. We define $\alpha:V(T)\to\Sigma^{*}_{\mathfrak{C}}$. such that for each $t\in V(T)$,

[TABLE]

By construction of $\mathfrak{C}$, $\alpha$ is a $(\mathfrak{C},G,\mathcal{D})$-witness.

Assume now that there exists a $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha:V(T)\to\Sigma^{*}_{\mathfrak{C}}$. Then by definition of $\mathfrak{C}$, for each $t\in V(T)$, $\alpha(t)$ is a $(\ell+1)$-tuple where the $\ell$ first coordinates are pairs with the shape $(m,V)$ where $m\in\Sigma^{*}_{\mathfrak{C}}$ and $V\subseteq V(G)$, and where $\alpha(t).(\ell+1)$ is an integer in $\left[0,p\right]$. For each $i\in\left[1,\ell\right]$, let $V_{i}=\bigcup_{t\in V(T)}\alpha(t).(i).(2)$, and let $\alpha_{i}:V(T)\to\Sigma^{*}_{\mathfrak{C}}$ be such that for each $t\in V(T)$, $\alpha_{i}(t)=\alpha(t).(i).(1)$. Then by definition of $\mathfrak{C}$, for each $i\in\left[1,\ell\right]$, $\alpha_{i}$ is a $(\mathfrak{C}_{i},G[V_{i}],\mathcal{D}_{i})$-witness, and so, $G[V_{i}]\in\mathcal{H}_{i}$. Note also that by definition of $\mathsf{Accept}_{\mathfrak{C}}$, $\mathsf{Process}_{\mathfrak{C},0}$, $\mathsf{Process}_{\mathfrak{C},1}$, and $\mathsf{Process}_{\mathfrak{C},2}$, the partition selected by $\alpha$ at step $t\in V(T)\setminus\{r\}$ is consistent with the one selected at step $t^{\prime}$ where $t^{\prime}$ is the parent of $t$. Combined with the definition of a tree decomposition, we obtain that $(V_{1},\ldots,V_{\ell})$ is a partition of $V(G)$. Moreover, as $\alpha$ is a $(\mathfrak{C},G,\mathcal{D})$-witness, we have that $\alpha(r).(\ell+1)\leq p$, and so $G\in\mathcal{H}$.

Let us now analyze the needed running time for this algorithm. Let $G$ be a graph and $\mathcal{D}=(T,r,\mathcal{X})$ be a rooted tree decomposition of $G$. Then for each partition $V_{1},\ldots,V_{\ell}$ of $Y_{t}$, there is at most $(p+1)^{2}$ ways to combine $p^{\prime}$ and $p^{\prime\prime}$ and so there are at most $(p+1)^{2}\cdot\prod_{i\in\left[1,\ell\right]}\mathsf{Size}(\mathfrak{C}_{i},G,\mathcal{D},t)$ ways to construct an element of $\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$ consistent with the partition. Moreover, we have $\ell^{|Y_{t}|}$ possible partitions of the set $|Y_{t}|$ into $\ell$ sets. Thus $|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq\ell^{|Y_{t}|}\cdot(p+1)^{2}\cdot\prod_{i\in\left[1,\ell\right]}\mathsf{size}(\mathfrak{C}_{i},G,\mathcal{D},t)$. In order to construct the data of $\mathfrak{C}$ associated to $(G,\mathcal{D})$, we first need, for each $i\in\left[1,\ell\right]$, to construct the data of $\mathfrak{C}_{i}$ associated to $(G[V],\mathcal{D}[V],t)$ for each $t\in V(T)$ and $V\subseteq Y_{t}$, and then, for each $t\in V(T)$ try every partition of $Y_{t}$ and combine the corresponding data accordingly. Thus, we have

[TABLE]

The theorem follows. ∎

Coloring problems are graph partition problems where it is not needed to keep track of the number of transversal edges. Thus the dynamic cores we present for the coloring problems are simpler than the one providing for the graph partition problems.

Theorem 11**.**

Let $\ell$ be an integer, let $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ be graph classes and let, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ be a dynamic core that solves $\mathcal{H}_{i}$. There exists a dynamic core $\mathfrak{C}$ that solves $\mathcal{H}=\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq\ell^{|Y_{t}|}\cdot\prod_{i\in\left[1,\ell\right]}\mathsf{size}(\mathfrak{C}_{i},G,\mathcal{D},t)$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{t\in V(T)}\left(\mathcal{O}(|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|)+2^{|Y_{t}|}\cdot\sum_{i\in\left[1,\ell\right]}\tau_{n}(\mathfrak{C}_{i},G,\mathcal{D},t)\right)$**

Proof.

Using the same base as for Theorem 10, we define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

The proof that $\mathfrak{C}$ solves $\mathcal{H}=\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ is omitted as it is similar to the one provided for Theorem 10 at the difference that this time we do not keep track of the transversal edges. ∎

Edge partitioning problems are really similar to coloring problem at the difference that the subgraphs we consider are induced by a set of edges instead of a set of vertices.

Theorem 12**.**

Let $\ell$ be an integer, let $\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell}$ be graph classes and let, for each $i\in\left[1,\ell\right]$, $\mathfrak{C}_{i}$ be a dynamic core that solves $\mathcal{H}_{i}$. There exists a dynamic core $\mathfrak{C}$ that solves $\mathcal{H}=\mathsf{EdgePart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ such that, for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,r,\mathcal{X})$ of $G$, and each $t\in V(T)$:

• •

$|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq\ell^{|E(G[Y_{t}])|}\cdot\prod_{i\in\left[1,\ell\right]}\mathsf{size}(\mathfrak{C}_{i},G,\mathcal{D},t)$**

• •

$\tau_{g}(\mathfrak{C},G,\mathcal{D})=\sum_{t\in V(T)}\left(\mathcal{O}(|\mathsf{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|)+2^{|E(G[Y_{t}])|}\cdot\sum_{i\in\left[1,\ell\right]}\tau_{n}(\mathfrak{C}_{i},G,\mathcal{D},t)\right)$**

Proof.

We define $\mathfrak{C}$ such that for each $G,G^{\prime},G^{\prime\prime}\in\mathcal{G}$,

[TABLE]

The proof that $\mathfrak{C}$ solves $\mathcal{H}=\mathsf{EdgePart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{\ell})$ is omitted as it is, again, similar to the one provided for Theorem 10 at the difference that this time we partition over the edges instead of the vertices and there are no transversal edges to consider. ∎

5 Applications

In this section we show how our results lead to significant simplification when looking for algorithms parameterized by treewidth. We first confront our approach against well-known problems, namely Vertex Cover and Graph $q$-Coloring, showing that we obtain comparable running time. We then show how this leads to quickly obtain algorithms for exotic problems, $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$ in our example, for which describing an algorithm in the usual way would have been long and tedious.

Vertex Cover, corresponding to $\mathsf{VertPart}(\mathcal{G}_{k},\mathcal{I})$ for some integer $k$, is well known to be solvable in time $2^{{\sf{w}}}\cdot n^{\mathcal{O}(1)}$ when a tree decomposition of width ${\sf{w}}$ of the input graph is given, see for instance [8, Theorem 7.9], while no algorithm running in time $2^{o({\sf{tw}})}\cdot n^{\mathcal{O}(1)}$ can solve it unless ETH fails [11]. Combining Observation 5, Observation 6, and Theorem 11, we obtain a dynamic core that solves Vertex Cover. Moreover, combined with Theorem 4, we obtain an algorithm solving Vertex Cover in time $2^{{\sf{w}}}\cdot n^{\mathcal{O}(1)}$ when a tree decomposition of width ${\sf{w}}$ of the input graph is given.

More generally, deletion problems are problems that attract a lot of attention and that can be considered as coloring problems. Indeed, given a graph class $\mathcal{H}$, the $\mathcal{H}$-deletion corresponds to the problem $\mathsf{VertPart}(\mathcal{G}_{k},\mathcal{H})$, for some integer $k$. Moreover, we show, in Observation 6 that $\mathcal{G}_{p}$-recognition, for some integer $p$, has a polynomial dynamic core. Combining Observation 6 with Theorem 11, we obtain that if there exists a dynamic core such that recognizing $\mathcal{H}$ can be done in time $2^{f({\sf{tw}})}\cdot n^{\mathcal{O}(1)}$ for some function $f$, then $\mathcal{H}$-deletion can be solved in time $2^{\mathcal{O}({\sf{tw}}+f({\sf{tw}}))}\cdot n^{\mathcal{O}(1)}$.

The most basic and well-known coloring problem is Graph $q$-Coloring. Again we obtain an asymptotically optimal algorithm, see for instance [8, Theorem 14.6 and Theorem 14.41], by combining Observation 5 and Theorem 11.

Corollary 13**.**

Graph $q$-Coloring* can be solved in time $q^{{\sf{w}}}\cdot n^{\mathcal{O}(1)}$ when a tree decomposition of width ${\sf{w}}$ of the input graph is given.*

Proof.

Given a fixed integer $q$, the Graph $q$-Coloring problem corresponds to $\mathsf{VertPart}(\mathcal{H}_{1},\ldots,\mathcal{H}_{q})$ where for each $i\in\left[1,q\right]$, $\mathcal{H}_{i}=\mathcal{I}$. The result follows from the combination of Observation 5 and Theorem 11. ∎

As discussed in the introduction, finding an algorithm for $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$ parameterized by the treewidth of the input graph is a question of interest in bioinformatics. By combining Observation 7, Theorem 11, and Theorem 4, we obtain an efficient algorithm solving $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$.

Corollary 14**.**

There exists an algorithm that solves $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$ in time $2^{\mathcal{O}({\sf{tw}})}\cdot n^{\mathcal{O}(1)}$.

To the best of our knowledge, the only other algorithm parameterized by treewidth for $\mathsf{VertPart}(\mathcal{T},\mathcal{T})$ was known using Courcelle’s theorem and run in time $2^{2^{\mathcal{O}({\sf{tw}})}}\cdot n^{\mathcal{O}(1)}$.

6 Conclusion

In this paper, we provide a generic tool for solving graph partition problems, coloring problems, and edge partition problems parameterized by the treewidth of the input graph. In particular, the developed approach provides a way, different than Courcelle’s theorem, to determine whether a problem is FPT parameterized by treewidth and also provides a first estimation of the expected running time of an algorithm solving the given problem. We would like to highlight the quality of these estimations as, for some well-known problems, they are asymptotically optimal.

In this conclusion we want to stress that when solving graph partition problems, we count the number of transversal edges. The illustrated technique allows, for instance, with some small modifications, to count separately transversal edges between different vertex sets of the partition. One can ask for instance for a partition of the vertex set of the input graph into three sets $V_{1}$, $V_{2}$, $V_{3}$ such that there are $k_{1,2}$ edges between $V_{1}$ and $V_{2}$, at most $k_{2,3}$ edges edges between $V_{2}$ and $V_{3}$, and no edge between $V_{1}$ and $V_{3}$ for some integers $k_{1,2}$ and $k_{2,3}$.

This approach also allows us to work with balanced partition. In this case, we first need to obtain the size of the input graph before constructing the dynamic core. Indeed we will need to intersect each graph class we consider with the class of graph of size $q$ (or $q+1$ if needed) for some correctly calculated $q$. For normalized cuts, this trick will not work as the target graph classes are not fixed before the algorithm starts to run.

More generally, we believe that using the dynamic programming core model, one can easily compose dynamic programming tree-decomposition-based algorithms with several added constraints. Moreover we also believe that it is adapted to quickly study exotic problems parameterized by treewidth.