Towards Work-Efficient Parallel Parameterized Algorithms

TL;DR

This paper explores how to design work-efficient parallel fixed-parameter tractable algorithms, balancing theoretical speed with practical efficiency on limited processor counts, by analyzing standard fpt methods.

Contribution

It introduces a framework for creating work-efficient parallel fpt algorithms by analyzing trade-offs in kernelization, search trees, and interleaving methods.

Findings

Proves trade-offs between work efficiency and runtime improvements.

Develops a toolbox for designing work-efficient parallel fpt algorithms.

Analyzes standard fpt techniques for parallelization efficiency.

Abstract

Parallel parameterized complexity theory studies how fixed-parameter tractable (fpt) problems can be solved in parallel. Previous theoretical work focused on parallel algorithms that are very fast in principle, but did not take into account that when we only have a small number of processors (between 2 and, say, 1024), it is more important that the parallel algorithms are work-efficient. In the present paper we investigate how work-efficient fpt algorithms can be designed. We review standard methods from fpt theory, like kernelization, search trees, and interleaving, and prove trade-offs for them between work efficiency and runtime improvements. This results in a toolbox for developing work-efficient parallel fpt algorithms.

Tables

Table 1. Table 1: Faster parallel algorithms for p ​ - subscript 𝑝 absent - p_{\mathit{}}\text{-}\penalty 15{\text{{}}} vertex-cover entail more work. We can achieve a runtime of O ​ ( 1 ) 𝑂 1 O(1) at the cost of the expensive use of color coding  [ 1 ] . If we allow O ​ ( log ⁡ n ) 𝑂 𝑛 O(\log n) time, a parallel Buss kernelization in conjunction with a simple brute force algorithm reduces the work. The next two lines are based on shallow search trees, discussed in Section  3.2 , and the work starts to become competitive with sequential algorithms. The last lines show that being work-competitive to the best known sequential algorithms implies larger and larger runtimes.

Work	Parallel Time
$O\left(kn+2^{2^k+k}\right)$	$O\left(1\right)$
$O\left(kn+2^{k^2}\cdot k^2\right)$	$O\left(\log n\right)$
$O\left(kn+3^k{k}^2\right)$	$O\left(\log n+{\log }^2\left(k\right)\right)$
$O\left(kn+2^k\right)$	$O\left(\log n+{\log }^4\left(k\right)\right)$
$O\left(kn+{1.6181}^k\right)$	$O\left(\log n+k\log \left(k\right)\right)$
$O\left(kn+{1.4656}^k\right)$	$O\left(\log n+k\log \left(k\right)\right)$
$O\left(kn+{1.2738}^k\right)$	$O(\log n+k^4\sqrt{k}))$

Equations

$$T_{\text{SeqSearchTree-B}}(n,k)=W_{\text{SeqSearchTree-B}}(n,k)$$

$$T_{\text{ParSearchTree-B}}(n,k)$$

$$W_{\text{ParSearchTree-B}}(n,k)$$

$$W_{{\text{K}}_{\text{init}}|\text{ParInterleave-B-Kinterleave}}(n,k)$$

$$\le$$

$$W_{{\text{K}}_{\text{init}}|\text{ParInterleave-B-Kinterleave}}(n,k)\le W_{{\text{K}}_{\text{init}}}(n,k)+(s_{{\text{K}}_{\text{init}}}(k){)}^{O(1)}+{\xi }_d^k$$

$$|d(x,k)|\cdot q(k)\le |d(x,k)|\cdot q(u(\epsilon k))\le \sum _{i=1}^{m}q(u(k_i)).$$

$$W_k\le {\sum }_{i=1}^{|d^k|}{W}_{k-d_i^k}+f_k,$$

$$1-{\sum }_{i=1}^{|d^k|}{x}^{d_i^k}$$

$$U_k=\xi U_{k-1}+f_k$$

$$W_k\le U_k$$

$$U_{k-i}\le {\xi }^{1-i}{U}_{k-1}.$$

$$W_k$$

$$\le {\sum }_{i=1}^{|d^k|}{U}_{k-d_i^k}+f_k$$

$$\le {\sum }_{i=1}^{|d^k|}{\xi }^{1-d_i^k}{U}_{k-1}+f_k$$

$$=\xi {\sum }_{i=1}^{|d^k|}{\xi }^{-d_i^k}{U}_{k-1}+f_k$$

$$\le \xi U_{k-1}+f_k$$

$$=U_k$$

Full text

1 Introduction

Since its introduction by Downey and Fellows [9] about thirty years ago, parameterized complexity theory has been successful at identifying which problems are fixed-parameter tractable (fpt), but has also had high practical impact. Efforts to formalize and devise parallel fpt algorithms date back twenty years [6, 7], but a lot of the theoretical research is quite recent [1, 2, 10]. The findings can be summarized, very briefly, as follows: (1) It is possible to classify the problems in the class $\mathrm{FPT}$ of fixed-parameter tractable problems according to how well they can be solved in parallel. (2) We find natural parameterized problems on all levels, from problems in $\mathrm{FPT}$ that are inherently sequential to problems that can be solved in constant (!) parallel time.

One aspect that the existing research lacks – and which may also explain the small number of actual implementations – is a fine-grained analysis of the work done by parallel fpt algorithms, which is defined as the total number of computational steps done by an algorithm summed over all processing units (in particular, for a sequential algorithm, its work equals its runtime). Unfortunately, “the work must be done”: on a machine with $p$ processors, a parallel algorithm with $W(n)$ work cannot finish faster than in time $W(n)/p$ on length-$n$ inputs. Since real-life values of $p$ are small (between 2 and perhaps 1024), a large $W(n)$ can lead to actual runtimes (“wall clock runtimes”) that are larger than those of sequential algorithms.

A common pattern in the design and analysis of parallel algorithms is that as we try to decrease the work $W(n)$ in order to get down the quotient $W(n)/p$, the “theoretical” parallel runtime $T(n)$ rises. This pattern is repeated in the fpt setting: Table 1 shows the work and time needed by different parallel algorithms for $p_{\mathit{}}\text{-}\penalty 15{\text{{vertex-cover}}}$. Note that we will never be able to reduce the work of a parallel algorithm below the work of the fastest sequential algorithm and an algorithm is called work-optimal if it matches this lower bound.

Our Contributions.

Many fpt algorithms are based on the search tree technique, which recursively traverses a search tree whose depth and degree are bounded by the parameter, resulting in a sequential runtime of the form $c^{k}$ or perhaps $(ck)^{k}$ for some constant $c$. Intuitively, search tree algorithms should be easy to parallelize since the different branches of the search tree can be processed independently. We show that this intuition is correct and we provide precise conditions for search tree algorithms under which they can be turned into work-efficient parallel algorithms. A parallel search tree algorithm still has to process, and thus construct, all branches of the tree, leading to a parallel runtime that is proportional to the depth of the search tree, which is normally $\Theta(k)$. This theoretical runtime is typically much smaller than the actual wall-clock time W(n)/p=\bigl{(}c^{k}+O(n)\bigr{)}/p>\!\!>k. However, we show that in some cases there is room for improvement and the runtime of $\Omega(k)$ can be replaced by $O(\log k)$ without increasing the work. The idea is to modify the search tree such that it “branches aggressively,” thereby reducing the depth to $O(\log k)$.

A second tool of parameterized complexity theory are kernelizations: mappings from input instances to membership-equivalent instances whose size is bounded by the parameter. Some problems admit more than one kernelization and we may be able to speedup the computation by applying all of them in a cleverly chosen order. For sequential computations, determining this order is simple: First apply the fastest kernel, which may however result in a still rather large instance. Then apply a slower kernel with a smaller output – the high runtime matters less since it is applied to a smaller input. Such kernel cascades are also possible in the parallel setting, but here kernelizations may have incomparable work, runtime, and output size. We provide a general procedure to combine a set of parallel kernelizations into a work-efficient and fast kernelization that minimizes the output size.

A third tool is interleaving: Instead of using a kernelization just as a preprocessing procedure, during a search tree traversal call the kernel algorithm at each tree node to ensure that the intermediate instances are small. In the sequential setting this has the desirable effect of turning a runtime of the form $O(k^{c}\cdot\xi^{k}+n^{c})$ into one of the form $O(\xi^{k}+n^{c})$ [14]. We show that interleaving is also possible in the parallel setting in a work-efficient manner, including the mentioned depth-$O(\log k)$ search trees that do not arise in the sequential setting.

Related Work.

First efforts to formalize parallel fpt algorithms are due to Cesati and Di Ianni [6], though the definitions were rather ad hoc. Around the same time, Cai et al. [5] investigated space bounded fpt algorithms – and since logarithmic space is closely related to parallel computations, these algorithms can be seen as parallel fpt results. A first experimental analysis of a parallel fpt algorithm for vertex cover is due to Cheetham et al. [7]. Recent work on a theoretical framework for parallel fpt has mainly been done by Bannach et al. [1, 2] and Elberfeld et al. [10]. These papers establish hierarchies of parallel parameterized complexity classes and place well-known problems in them, but do not consider work-efficiency. Many algorithms in the cited papers are based on the expensive color-coding technique, which needs work $O(n\log^{2}n\log c\cdot c^{k^{2}}\cdot k^{4})$ and results in unpractical algorithms.

Organization of This Paper.

Following the preliminaries, we investigate, in order, parallel search trees, parallel kernels, and parallel interleaving.

2 Preliminaries

A parameterized problem $Q$ is a set $Q\subseteq\Sigma^{*}\times\mathbb{N}$, where in an instance $(x,k)\in\Sigma^{*}\times\mathbb{N}$ the number $k$ is called the parameter. A parameterized problem is fixed-parameter tractable (in $\mathrm{FPT}$) if there is an algorithm that decides for all $(x,k)\in\Sigma^{*}\times\mathbb{N}$ whether $(x,k)\in Q$ holds in time $f(k)\cdot|x|^{c}$. Here, and in the following, $f$ is always a computable function and $c$ a constant. As model of parallel computation we use standard prams (rather than circuits), see for instance [12]. For a pram program, let $T_{p}(n)$ denote the maximum time the program needs on inputs of length $n$ when $p$ processors are available. Let $T(n)=\inf_{p\to\infty}T_{p}(n)$ and let $W(n)$ denote the maximum number of computational steps (summed over all non-idle processors) performed by the algorithm on inputs of length $n$. It is well-known that $T_{p}(n)\leq W(n)/p+T(n)$ holds when the set of non-idle processors is easily computable for each step (so a compiler can schedule the to-be-done work for each step when less processors are available than there is work to be done) [12]. We have $T_{p}(n)\geq W(n)/p$ and $T_{p}(n)\geq T(n)$. Since for fast parallel algorithms we have $W(n)/p>\!\!>T(n)$, the work of a parallel algorithm is the dominating factor. We say an algorithm is work-optimal if its work is the best possible among all algorithms. This definition hinges, to a certain degree, on the fact that there are clear notions of “minimal work” and “minimal runtime”. In the parameterized world, however, this is no longer the case: it is not clear which of the terms $3^{k}n$, $2^{k}n^{2}$, $n^{3}+2^{k}$, and $n^{k}$ is “minimal.” Depending on the values of $n$ and $k$, any of the terms may be more desirable than the others. For this reason, we strive for optimality only with respect to the following notion (throughout the paper, we assume that functions like $W(n,k)$ or $T(n,k)$ are monotone with respect to both parameters): An algorithm $A$ is work-competitive to a function $f$ if $W_{A}\in O(f)$, that is, if $W_{A}(n,k)\leq c\cdot f(n,k)$ for all $n\geq n_{0}$ and $k\geq k_{0}$ for some constants $c$, $n_{0}$, and $k_{0}$. An algorithm $A$ is work-competitive to an algorithm $B$ if it is work-competitive to the function $W_{B}$.

3 Work-Efficient Parallel Search Tree Algorithms

For a parameterized problem $Q$ and an instance $(x,k)$, a search tree algorithm invokes a branching rule (or branching algorithm) to determine a sequence $(x_{1},k_{1})$, …, $(x_{m},k_{m})$ of new instances such that $(x,k)\in Q$ if, and only if, we have $(x_{i},k_{i})\in Q$ for at least one $i$. Crucially, each $k_{i}$ must be smaller than $k$, that is, $d_{i}=k-k_{i}>0$. (Let us also require $|x_{i}|\leq|x|$ to simplify the presentation, but this is less crucial.) The search tree algorithm recursively calls itself on these new instances (unless it can directly decide the instance for “trivial” $k$ or for “trivial” $x_{i}$). An example of a search tree algorithm is the branching algorithm for the vertex cover problem where we “branch on an arbitrary edge”: Map $(G,k)$ to $(G-\{u\},k-1)$ and $(G-\{v\},k-1)$ for an arbitrary edge $\{u,v\}$ (we have $d_{1}=d_{2}=1$ and $m=2$). Another example is the branching rule “branch on the maximum-degree vertex and either take it into the vertex cover or all of its neighbors,” meaning that we map $(G,k)$ to $(G-\{u\},k-1)$ and $(G-N(u),k-|N(u)|)$ where $N(u)$ is the neighborhood of $u$. This leads to $d_{1}=1$ and $d_{2}=|N(u)|$; and since we can solve the vertex cover problem directly in graphs of maximum degree $2$, we have $d_{1}=1$ and $d_{2}\geq 3$.

3.1 Simple Parallel Search Trees

As mentioned in the introduction, parallelizing a search tree is more or less trivial, since we can process all resulting branches in parallel. Of course, it may now become important how well the branching rule can be parallelized, since we have to invoke it on each level of the tree. In detail, for a set $D$ of vectors $d=(d_{1},\dots,d_{m})$, a $D$-branching algorithm B for $Q$ is an algorithm that on input $(x,k)$ either correctly outputs “$(x,k)\in Q$”, “$(x,k)\notin Q$”, or instances $(x_{1},k-d_{1})$, …, $(x_{m},k-d_{m})$ for some $d\in D$ such that $(x,k)\in Q$ if, and only if, $(x_{i},k-d_{i})\in Q$ for some $i\in\{1,\dots,m\}$. Let SeqSearchTree-B and ParSearchTree-B denote the sequential and parallel search tree algorithms based on B, respectively. Note that both algorithms traverse the same tree on an input $(x,k)$. Let $\operatorname{size}_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ and $\operatorname{depth}_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ denote the maximum number of nodes and the maximum depths of the search trees traversed by the algorithms on inputs of length $n$ and parameter $k$, respectively.

From a sequential perspective, the objective in the design of search tree algorithms is to reduce the size of the search tree since this will be the dominating factor in the runtime. From the parallel perspective, however, we will also be interested in the depth of the search tree since, intuitively, this depth corresponds to the parallel time needed by the algorithm.

Theorem 3.1

Let B be a branching algorithm. Then

[TABLE]

Proof

This follows directly from the definitions. Note that the runtime of a sequential simulation of a parallel algorithm B takes time $W_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ and if B is already a sequential algorithm, then $T_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)=W_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$. ∎

Of course, a lot is known concerning the size of search trees resulting from $D$-branching algorithms: If $s(k)=\operatorname{size}_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ is independent of $n$, we always have $s(k)\leq\max_{(d_{1},\dots,d_{m})\in D}(s(k-d_{1})+\cdots+s(k-d_{m})+1)$ and it is known [14] how to compute a number $\xi_{D}$ such that $s(k)=\Theta(\xi_{D}^{k})$ is a minimal solution of the inequality: for $d=(d_{1},\dots,d_{m})$ the number $\xi_{d}$ is the reciprocal of the minimal root of the polynomial $p(x)=1-\sum_{i=1}^{m}x^{d_{i}}$ and $\xi_{D}=\sup_{d\in D}\xi_{d}$. For instance, for the simple branching algorithm for the vertex cover problem with $D=\{(1,1)\}$ we have $\xi_{D}=2$ and the search tree has size $2^{k}$, while for $D=\{(1,3);(1,4);(1,5);\dots\}$ from the branch-on-a-degree-3-vertex algorithm we have $\xi_{D}=\xi_{(1,3)}\approx 1.4656$. Regarding the depth of the search tree, it is clearly upper-bounded by $k/\min d$ for the “worst $d\in D$” since in each recursive call we decrease $k$ by at least the minimal $d_{i}$ in $d$. In summary, we see that ParSearchTree-B is always work-competitive to SeqSearchTree-B and $T_{\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}}(n,k)=\smash{\frac{k}{\max_{d\in D}\min_{i}d_{i}}}\cdot T_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ and $W_{\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}}(n,k)=\xi_{D}^{k}\cdot W_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$.

3.2 Shallow Parallel Search Trees

If we wish to find faster work-optimal parallel search tree algorithms, a closer look at Theorem 3.1 shows that there are two lines of attack: First, we can try to decrease $T_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ while keeping $W_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ optimal. Second, we can try to decrease the depth of the search trees without increasing their size.

Regarding the first line of attack, there is often “little that we can do” since $T_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)$ will often already be optimal. For instance, the branching algorithm “pick an arbitrary edge” can be implemented optimally in parallel time $O(1)$ assuming an appropriate memory access model; and for the branch-on-a-degree-3-vertex algorithm, both finding a degree-3 vertex and solving the instance if no such vertex exists can be done work-optimally in polylogarithmic time.

Regarding the second line, however, new algorithmic ideas are possible and lead to work-efficient algorithms whose runtime is logarithmic in the parameter instead of linear. A word of caution, however, before we proceed: We improve runtimes from $O(k+\log^{O(1)}n)$ to $O(\log k+\log^{O(1)}n)$, where the $O(\log n)$ is needed already for many pre- and postprocessing operations on the input. Clearly, the improvement in the runtime is rather modest since we generally think of $k$ being something very small. Nevertheless, achieving even this modest speedup optimally is highly nontrivial for many problems.

To get some intuition for the idea, consider once more the vertex cover problem, but let us now try to find ten arbitrary edges that form a matching. Then every vertex cover of the input graph must contain at least one endpoint from each of these ten edges and we get the following new branching rule: Branch to all 1024 possible ways of choosing one vertex from each of the ten edges, each time reducing the size of sought vertex cover by 10. This corresponds to a branching vector $d^{\prime}=(10,10,\dots,10)$ of length 1024; compared to the vector $d=(1,1)$ if we branch over a single edge. In the sequential setting this idea only complicates things since $\xi_{d^{\prime}}=\xi_{d}=2$ and this new algorithm produces a search tree of the same size as before. In contrast, in the parallel setting we make progress as the depth of the search tree is decreased by a factor of 10, without an increase in the work being done. Naturally, a factor-10 speedup is just a constant speedup, but we can extend the idea to move from a runtime of $k$ to $\log k$:

Theorem 3.2

There is an algorithm that solves $p_{\mathit{}}\text{-}\penalty 15{\text{{vertex-cover}}}$ in time $T(n,k)=O(\log k\cdot\log^{3}n)$ and work $W(n,k)=O(2^{k}n)$ on a crcw-pram.

Proof

On input $(G,k)$ we determine a maximal matching $M$ in $G$. Clearly, if $|M|>k$, then no vertex cover of size $k$ is possible and we can just ouput “$(G,k)\notin{\text{{vertex-cover}}}$”; and if $|M|\leq k/2$, then the endpoints of the edges in $M$ form a vertex cover of size at most $2|M|\leq k$, again allowing us to stop immediately. The interesting case is thus $k/2\leq|M|\leq k$ and, here, we branch over all $2^{|M|}$ possible ways in which we can chose one endpoint from each edge. In the worst case, this gives a branching vector $d=(k/2,\dots,k/2)$ of length $2^{k/2}$. In particular, in each branching step we reduce the target size of the vertex cover by at least 50% and, thus, after at most $O(\log k)$ steps we arrive at a trivial instance. The size of the search tree is not affected and, thus, still has size $2^{k}$. Since it is known [11] that maximal matchings can be computed in time $O(\log^{3}n)$ and linear work, we obtain the claim. ∎

The above theorem and its proof transformed a simple “original” search tree for the vertex cover problem into a “highly parallel” one. The key concepts behind this transformation were the following:

• •

Branch structures: The original branching algorithm first found “a substructure on which to branch.” For example, the vertex cover branching algorithm normally finds “an arbitrary edge;” the branch-on-degree-at-least-3 algorithm finds “a high-degree vertex.”

• •

Conflict-free branch structures: If the original branching algorithm has the choice among several possible substructures on which it could branch and if the substructures are disjoint, we can also branch on these structures “in parallel.” In Theorem 3.2, “disjoint substructures that are edges” are matchings and we can branch on them in parallel; for the branch-on-degree-at-least-3 algorithm we can branch in parallel on any star forest.

• •

A large number of conflict-free branch structures: Lastly, we need to be able to find a large enough collection of such disjoint substructures quickly and work-efficiently. Its size needs to be at least a fraction of the parameter to ensure that we get a depth that is logarithmic in the parameter.

Since formalizing the above notions can easily lead to rather technical definitions, we suggest a formalization that is not as general as it could be, but that nicely captures the essential ideas. We only consider vertex search problems $Q$ on simple graphs where the objective is to find a parameter-sized subset of the vertices that has a certain property. Concerning branching rules, we only consider rules that identify a subset of the vertices and then branch over different ways in which some of these vertices can be added to the partial solution:

Definition 1 (Local branching rule)

Let $Q$ be a vertex search problem. A local branching rule is a partial mapping that gets a tuple as input consisting of a graph $G=(V,E)$, a parameter $k$, an already computed partial solution $P\subseteq V$, and a set $S\subseteq V\setminus P$ on which we would like to branch. If defined, it outputs a family $F$ of nonempty subsets of $S$ such that for every solution $Y\supseteq P$ for $(G,k)$ the intersection $Y\cap S$ is a superset of an element of $F$.

The local branching rule for the vertex cover algorithm maps the tuple $(G,k,P,\{u,v\})$ with $\{u,v\}\in E$ and $u,v\notin P$ to $\{\{u\},\{v\}\}$ and is undefined otherwise. For the branch-on-degree-at-least-3 rule, if $S$ is the closed neighborhood in $G-P$ of some vertex $v$ of degree $3$ in $G-P$, we map $(G,k,P,S)$ to $\{\{v\},S\setminus\{v\}\}$. Returning to the three ingredients of the proof of Theorem 3.2, the sets $S$ in the definition of a local branching rule are exactly the sought “branching structures.” A collection $M$ of such sets is “conflict-free” if all members of $M$ are pairwise disjoint. In the proof of Theorem 3.2 such an $M$ was simply a matching in the graph; but given any collection $N$ of sets $S$, any maximal set packing $M\subseteq N$ will be conflict-free. Maximal set packings can be obtained efficiently and quickly in parallel by building a conflict graph over the sets and computing a maximal independent set [13]. Therefore, in a general setting it suffices to compute a polynomial-size set $N$ of sets $S$ that has a set packing $M\subseteq N$ whose size at least a fraction of $k$. Algorithm 1 makes these ideas precise.

Definition 2

An implementation of a local branching rule consists of three algorithms decide, choices, and branches with the following properties:

On inputs $(G,k,P)$ for which there is no $S$ such that the local branching rule is defined for $(G,k,P,S)$, algorithm decide must correctly output “yes” or “no” depending on whether $P$ is a partial solution. 2. 2.

For all other inputs $(G,k,P)$, the algorithm choices must output a nonempty set $N$ such the local branching rule is defined on all $(G,k,P,S)$ for $S\in N$. 3. 3.

For all $(G,k,P,S)$ for which the local branching rule is defined, branches must output the corresponding family $F$ of branches.

Theorem 3.3

Given an implementation $(\mathchoice{\text{{decide}}}{\text{{decide}}}{\text{{decide}}}{\text{{decide}}},\mathchoice{\text{{choices}}}{\text{{choices}}}{\text{{choices}}}{\text{{choices}}},\mathchoice{\text{{branches}}}{\text{{branches}}}{\text{{branches}}}{\text{{branches}}})$ for a local branching rule for some $Q$, algorithms $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{1}$ and $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ from Algorithm 1 satisfy:

$\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}_{*}$* is work-competitive to $\mathchoice{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}_{1}$ if $W_{\mathchoice{\text{{decide}}}{\text{{decide}}}{\text{{decide}}}{\text{{decide}}}}(n,k)+W_{\mathchoice{\text{{choices}}}{\text{{choices}}}{\text{{choices}}}{\text{{choices}}}}(n,k)+W_{\mathchoice{\text{{branches}}}{\text{{branches}}}{\text{{branches}}}{\text{{branches}}}}(n,k)\in\Omega(n^{3})$.* 2. 2.

If the size of the maximal set packings $M$ computed by $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ is always at least $\varepsilon(k-|P|)$ for some $\varepsilon>0$, then $T_{\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}_{*}}(n,k)=O(\log k\cdot(T_{\mathchoice{\text{{decide}}}{\text{{decide}}}{\text{{decide}}}{\text{{decide}}}}(n,k)+T_{\mathchoice{\text{{choices}}}{\text{{choices}}}{\text{{choices}}}{\text{{choices}}}}(n,k)+T_{\mathchoice{\text{{branches}}}{\text{{branches}}}{\text{{branches}}}{\text{{branches}}}}(n,k)+\log^{4}n))$.

Proof

To see that $\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}_{*}$ is work-competitive to $\mathchoice{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}_{1}$ first note that both algorithms produce search trees of the same size (albeit different depths) since each parallel branching done by $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ over $S_{1},\dots,S_{m}$ corresponds to a sequential branching of $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{1}$ over the same sets in an arbitrary order. At this point it is important that in $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ we restrict the size of $M$ to $(k-|P|)/(s+1)<(k-|P|)/s$ – otherwise, $\mathchoice{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}_{1}$ might “immediately notice after one branching” that an input like $(G,2,\emptyset)$ does not have a solution, while $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ might output a huge set $M$ and would then branch in a great number of ways, only to notice immediately in each branch that no solution results. For instance, if $G$ is a size-1000 matching, then $\mathchoice{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}{\text{{SeqSearchTree-B}}}_{1}$ would notice after one branching that $(G,2,\emptyset)$ has no solution, while an unrestricted maximal matching in $G$ obviously has size $1000$ and $\mathchoice{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}{\text{{ParSearchTree-B}}}_{*}$ would branch in $2^{1000}$ ways, each time immediately noticing that the solution is 998 vertices too large.

Additional work inside the algorithm $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ is caused by the need to compute a maximum set packing. This can be done by constructing a conflict graph, which requires work $O(n^{3})$, and then applying the parallel maximal independent set algorithm by Karp and Wigderson [13], which requires work $O(n^{2})$.

Concerning the runtime, note that by assumption each time $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ calls itself recursively, the size of $k-|P|$ is shrunk by at least a factor of $\varepsilon$. Thus, starting with $P=\emptyset$, after $O(\log k)$ rounds we will have $|P|=k$ and no further branching will happen. This immediately gives us the claimed runtime since computing maximal set packings can be done in time $O(\log^{4}n)$, see [13]. ∎

4 Work-Efficient Parallel Kernels

Kernels are self-reductions that map instances to new instances whose size is bounded in terms of the parameter. Like search trees, they are basic concepts of fpt theory. Unlike search trees, kernels are often hard to parallelize: They are typically described in terms of reduction rules, which locally change an input instance in such a way that it gets a bit smaller without changing problem membership and such that at least one rule is still applicable as long as the instance size is not bounded in terms of the parameter. Unfortunately, it is known that some sets of reduction rules are “inherently sequential,” meaning that computing the result of applying them exhaustively is complete for sequential polynomial time [4]. On the other hand, some reduction rules can easily be applied in parallel just as well as sequentially, leading to kernelization algorithms running in polylogarithmic time or even in constant time [3].

While it seems hard to characterize which sets of reduction rules yield parallel kernels, the situation is more favorable when we consider a sequence of kernels (a kernel cascade). In the sequential setting, the situation is simple: Given several kernelizations for the same problem, the asymptotically fastest way to compute a minimum-size kernel is simply to apply them in sequence starting with the fastest and ending with the slowest. In the parallel setting, the situation is also simple when we can parallelize all kernels of a cascade optimally. However, even when this is not the case, we may still get a fast parallel algorithm and there is an intriguing dependence on the parallel runtime and the kernel size: Theorem 4.2 states that it suffices to parallelize the kernels in a cascade until the kernel size equals the desired parallel runtime – while later kernels need not be parallelized.

4.1 Sequential Kernel Cascades

A kernelization for a parameterized problem $Q\subseteq\Sigma^{*}\times\mathbb{N}$ is a polynomial-time computable function $K\colon\Sigma^{*}\times\mathbb{N}\to\Sigma^{*}\times\mathbb{N}$ such that (a) $(x,k)\in Q$ if, and only if, $K(x,k)\in Q$ for the kernel $K(x,k)$ and such that (b) for some computable function $s_{K}$ we have $|K(x,k)|\leq s_{K}(k)$ for all $x$ and $k$. We call the kernelization polynomial if $s_{K}$ is a polynomial. A kernel algorithm is an algorithm K that computes a kernelization $K$.

As indicated earlier, there can be several kernelizations (and, hence, kernel algorithms) for the same problem and they may differ regarding their runtime and their kernel sizes. For instance, on input $(G,k)$ the Buss kernelization of the vertex cover problem removes all vertices of degree larger than $k$ (which must be in a vertex cover) and then removes all isolated vertices (which are not needed for a vertex cover). It yields kernels of size $s_{\mathchoice{\text{{Buss}}}{\text{{Buss}}}{\text{{Buss}}}{\text{{Buss}}}}(k)=k^{2}$ and can be computed very quickly. In contrast, the linear program kernelization [8] for the vertex cover problem solves a linear program in order to compute a kernel of size $2k$, but solving the linear program takes more time. It now makes sense to first compute a Buss kernel followed by an application of the linear program kernelization since we then apply a “slow” algorithm only to an already reduced input size (from originally $n$ to only $k^{2}$).

In general, let a kernel cascade be a sequence $C=(\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t})$ of kernel algorithms for the same parameterized problem $Q$ sorted in strictly increasing order of runtime (that is, we require $T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i}}\in o(T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i+1}})$ and thereby implicitly rule out situations where runtimes are incomparable) and strictly decreasing order of kernel sizes (that is, we require $s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i}}(k)>s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i+1}}(k)$ for all but finitely many $k$). The cascaded kernel algorithm $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C}$ of a cascade $C$ will, on input $(x,k)$, first apply $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1}$ to $(x,k)$, then applies $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{2}$ to the result, then $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{3}$ and so on, and output the result of the last $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t}$. Clearly, the following holds:

Observation 4.1

Let $C=(\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t})$ be an kernel cascade. Then $s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C}}=s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t}}$ and the runtime of $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C}$ is $T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C}}(n,k)=T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1}}(n)+T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{2}}(s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1}}(k))+T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{3}}(s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{2}}(k))+\cdots+T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t}}(s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t-1}}(k)).$ Furthermore, no subsequence $C^{\prime}$ of $C$ with $s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C^{\prime}}}=s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t}}$ achieves an asymptotically faster runtime.

4.2 Parallel Kernel Cascades

Faced with the problem that kernels based on reduction rules are often difficult to parallelize, parallelizing a whole kernel cascade in a work-optimal way seems even more challenging: Observation 4.1 states that for a given cascade the asymptotically fastest runtime is achieved by applying all kernels in the cascade in sequence. Since “work optimal” means, by definition, “parallel work equal to the fastest sequential runtime,” we also must apply work-optimal parallel versions of all kernels in the cascade in sequence in the parallel setting.

It turns out that it may not be necessary to parallelize all kernels in a cascade: Suppose we only parallelize the first kernel in a cascade, that is, suppose we find a work-optimal algorithm for $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1}$ with runtime $O(\log^{O(1)}n)$ and then apply this parallel algorithm followed by the unchanged sequential kernels $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{2}$ to $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t}$. The work of the resulting cascade will be identical to the runtime of the original sequential cascade (since $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1}$ is work-optimal and nothing else is changed). The runtime, however, will now be $O(\log^{O(1)}n)$ plus some function that depends only on $k$ (since all later kernels are applied to inputs whose size depends only on $k$). Assuming that we consider a runtime of the form $O(\log^{O(1)}n+f(k))$ “acceptable,” we see that we can turn any sequential kernel cascade into a parallel one by parallelizing only the first kernel. Of course, there are functions $f$ that we might not consider “acceptable”; for instance, $f$ might be exponential. Intuitively, we then need to “parallelize more kernels of the sequence.”

Theorem 4.2

Let $C=(\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t})$ be a kernel cascade and for some $r\leq t$ let $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{r}$ be parallel implementations of $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{r}$, that is, for $i\in\{1,\dots,r\}$ let $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{i}$ be a work-competitive parallel implementation of $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i}$ with runtime $T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{i}}\in O(\log^{O(1)}n)$. Let $C^{\prime}=(\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{r},\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{r+1},\dots,\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{t})$. Then

$\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C^{\prime}}$* is work-competitive to $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C}$ and* 2. 2.

$T_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{C^{\prime}}}(n,k)=\log^{O(1)}n+s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{r}}(k)^{O(1)}$.

Proof

Consider arbitrary kernel cascades $C$ and $C^{\prime}$ defined as above. Since $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}^{\prime}_{i}$ is work-competitive to $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{i}$ and they have asymptotically the same kernel size $s_{K^{\prime}_{i}}\in O(s_{K_{i}})$ for every $i\in\{1,\dots,r\}$, it follows by Observation 4.1 that the cascade $C^{\prime}_{\Delta}=(K^{\prime}_{1},\dots,K^{\prime}_{r})$ is work-competitive to the cascade $C_{\Delta}=(K_{1},\dots,K_{r})$. Furthermore, $s_{C^{\prime}_{\Delta}}\in O(s_{C_{\Delta}})$. In both cascades $C$ and $C^{\prime}$, the remaining phases after computing a similar-sized kernel by $C_{\Delta}$ and $C^{\prime}_{\Delta}$ are equal. Since in both cases the input for this phase has similar size, we get that $C^{\prime}$ is work-competitive to $C$.

In $C^{\prime}$, for every $i\leq r$ the kernel $K^{\prime}_{i}$ needs parallel time $\smash{T_{K^{\prime}_{i}}(n)=\log^{O(1)}n}$. It follows directly that $T_{C^{\prime}_{\Delta}}(n)\in O(\log^{O(1)}n)$. The output of the first stage has size at most $s_{K^{\prime}_{r}}(k)$. The dominating work in the remaining phase of the cascade $C^{\prime}$ is the polynomial work of the last kernel algorithm. Since this work is polynomial in $n$, we directly get a maximal work of $s_{K^{\prime}_{r}}(k)^{O(1)}$, which completes the proof. ∎

As a concluding example, consider once more $p_{\mathit{}}\text{-}\penalty 15{\text{{vertex-cover}}}$. We mentioned already that there is a size-$k^{2}$ kernel algorithm Buss for this problem, which is easy to implement in linear sequential time, but also in logarithmic parallel time and linear work (and, thus, optimally). There is also a size-$2k$ kernel algorithm LP based on [8] that needs sequential time $O(|E|\sqrt{|V|})$. For this kernel, no work-optimal (deterministic) polylogarithmic time implementation is known (indeed, any parallel implementation is difficult to achieve [4]). By Observation 4.1, there is a sequential kernel algorithm for the vertex cover problem that runs in time O\bigl{(}n+k^{2}\sqrt{k^{2}}\bigr{)}=O(n+k^{3}). By Theorem 4.2, there is a parallel kernel algorithm that is work-competitive and needs time $O(\log n+k^{3})$.

5 Work-Efficient Parallel Interleaving

Interleaving is a method to combine a branching algorithm B and kernel algorithm K to “automatically” reduce the runtime of SeqSearchTree-B: During the recursion, the algorithm SeqInterleave-B-K applies K at the beginning of each recursive call (thus, calls to the kernel algorithm are “interleaved” with the recursive calls, hence the name of the method). Intuitively, at the start of the recursion, calling a kernel algorithm is superfluous (the input is typically already kernelized) and only adds to the runtime, but deeper in the recursion it will ensure that the inputs are kept small. Since the bulk of all calls are “deep inside the recursion” we can hope that “keeping things small there” has more of a positive effect than the negative effect caused by the superfluous calls at the beginning. Niedermeier and Rossmanith have shown that this intuition is correct:

Fact 5.1** ([14])**

Let K be an arbitrary kernel algorithm that produces kernels of polynomial size. Let B be a $d$-branching algorithm running in polynomial time. Then $T_{\mathchoice{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}}(n,k)=\operatorname{size}_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(n,k)+n^{O(1)}\leq\xi_{d}^{k}+n^{O(1)}.$

5.1 Simple Parallel Interleaving

Interleaving also helps to reduce the work of parallel search tree algorithms: Consider the algorithm ParInterleave-B-K, the version of ParSearchTree-B that applies K at the beginning of each recursive call. First applying K and then computing branch instances using B is itself a branching algorithm and, thus, Theorem 3.1 tells us that $T_{\mathchoice{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}{\text{{SeqInterleave-B-K}}}}(n,k)=W_{\mathchoice{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}}(n,k)$ holds. This observation suggests that in order to minimise the work, we have to choose the most work-efficient kernel algorithm K available to us. However, it turns out that we have more options in the parallel setting: The work of K is only relevant at the very beginning, when the input size still depends on $n$. Later on, all remaining computations get inputs whose size depends only on the parameter. For these calls, the work of K is no longer relevant – it is “drowned out” by $\xi_{D}^{k}$. This suggests the following strategy: We use two kernels, namely an initial kernel whose job is to quickly and, more importantly, work-efficiently reduce the input size once (how such kernels can be constructed was exactly what we investigated in Section 4); and then use an interleaving kernel during the actual interleaving, whose job is just to kernelize the intermediate instances as quickly as possible – but we need no longer care about the work! Let us write $\mathchoice{\text{{A}}}{\text{{A}}}{\text{{A}}}{\text{{A}}}|\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}$ for the sequential concatenation of algorithms A and B.

Theorem 5.2

Let B be a $d$-branching algorithm, and let $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\mathchoice{\text{{init}}}{\text{{init}}}{\text{{init}}}{\text{{init}}}},\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\mathchoice{\text{{interleave}}}{\text{{interleave}}}{\text{{interleave}}}{\text{{interleave}}}}$ be polynomial-sized kernels. Then W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\mathchoice{\text{{init}}}{\text{{init}}}{\text{{init}}}{\text{{init}}}}|\mathchoice{\text{{ParInterleave-B-K{}{\text{inteleave}}}}}{\text{{ParInterleave-B-K{}{\text{inteleave}}}}}{\text{{ParInterleave-B-K{}{\text{inteleave}}}}}{\text{{ParInterleave-B-K{}{\text{inteleave}}}}}}(n,k)\in O(W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\mathchoice{\text{{init}}}{\text{{init}}}{\text{{init}}}{\text{{init}}}}}(n,k)+\xi_{d}^{k}).

Proof

Let $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}},\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\text{init}},$ and $\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\text{interleave}}$ be algorithms as defined above. It is easy to see that

[TABLE]

From Fact 5.1 we get

[TABLE]

and finally with $(s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}_{\text{init}}}(k))^{O(1)}\in O(k^{O(1)})$ we get the claim. ∎

5.2 Shallow Parallel Interleaving

At the end of Section 3 we introduced the idea of shallow search trees as a method to speedup parallel search tree algorithms. However, shallow search trees are not necessarily compatible with the interleaving technique: From the parallel point of view, a “perfect” branching algorithm would branch on input $(G,k)$ in constant time to $m=\xi_{D}^{k}$ simple instances $(G_{1},1),\dots,(G_{m},1)$, all of which can then be processed in parallel. Applying a kernel at this point is “too late”: The work will be something like $m=\xi_{D}^{k}$ times the work of the kernel, which is decidedly not of the form $\xi_{D}^{k}$ plus the work of the kernel.

What goes wrong here is, of course, that we parallelize “too much”: we must ensure that the kernel algorithm gets a chance to kick in while the inputs still have a large enough size. On inputs of (still) large parameter $k$, all branches have to have a parameter of size at least $\varepsilon k$ (normally, we want a parameter at most $\varepsilon k$). We remark that it does not follow from [14] that interleaving is possible here since [14] considers only the case where the number of branch instances is bounded by a constant. For the following theorem, let us write $d(x,k)$ for the branching vector $d$ used by B on input $(x,k)$ and $|d(x,k)|$ for its length.

Theorem 5.3

Let B be a $D$-branching algorithm such that for all inputs $(x,k)$, (a) the work done by B is at most $|d(x,k)|\cdot|x|^{O(1)}$ and (b) the maximum value in $d(x,k)$ is at most $(1-\varepsilon)k+O(1)$. Let K be a polynomially-sized kernel algorithm. Then $W_{\mathchoice{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}{\text{{ParInterleave-B-K}}}}(n,k)=O(W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(n,k)+\xi_{D}^{k})$.

Proof

Let B be a $D$-branching algorithm as in the theorem. We first show that the total work of a shallow search tree algorithm can be mapped to nodes of a tree such that every node is labelled with a polynomial work $p(k)$ instead of some superpolynomial work $\left|d(x,k)\right|k^{O(1)}$. Then we show that we get the same upper bound for the total work in this tree according to arguments from [14].

Consider the tree of ParInterleave-B-K for an arbitrary input. Each node in this tree is an instance $x$ with its parameter $k$. ParInterleave-B-K runs the kernel algorithms K and the branching algorithm B on these instances. Let us label each node in the traversed tree with the work $W_{1}(x,k)$ that is necessary to run $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}|\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}$ at this point, and let us use $T_{1}$ to denote this tree. For $T_{1}$ there is an upper bound $u(k)=k/\varepsilon+O(1)$ such that for each node $(x,k)$ and its parent node $(x^{\prime},k^{\prime})$, we have that $k^{\prime}\leq u(k)$. The sole exception is the root of $T_{1}$. This holds because every value in $d(x,k^{\prime})$ is at most $(1-\varepsilon)k^{\prime}+O(1)$ such that $k\geq k^{\prime}-(1-\varepsilon)k^{\prime}+O(1)$. Since K is a polynomial kernel algorithm, each node with an instance $x$ and a parameter $k$ in $T_{1}$ is labelled with at most $W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,u(k))+|d(x,k)|\cdot q(k)$ for some polynomial $q$. Note that the total work of ParInterleave-B-K is the sum of the labels over all nodes of $T_{1}$. We can construct another labelled tree $T_{2}$ such that the sum of its labels is more than the total work of $T_{1}$ and such that the labels are bounded by a polynomial: Let $T_{2}$ consists of the same nodes as $T_{1}$, and let each node $(x,k)$ be labelled with $W_{2}(x,k)=W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,u(k))+2q(u(k))$. Since $W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}$, $s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}$, $q$, and $u$ are polynomials, $W_{2}$ is also a polynomial. We show that the total sum of all labels in $T_{1}$ is smaller than the total sum of labels in $T_{2}$. We can ignore the term $W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,u(k))$ because it is part of both labels. Consider some node $(x,k)$ in $T_{1}$ and in $T_{2}$: If $(x,k)$ has no children, then it is easy to see that $W_{1}(x,k)-W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,u(k))\leq W_{\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}}(s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(k),k)=q(k)\leq q(u(k))=\frac{W_{2}(x,k)-W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,u(k))}{2}$. Otherwise, we have $|d(x,k)|$ many children $(x_{1},k_{1}),\dots,(x_{m},k_{m})$, and for every $(x_{i},k_{i})$ we know that $k_{i}\geq\varepsilon k$. It follows that

[TABLE]

As a result, the work of $(x,k)$ in $T_{1}$ can be mapped to the work of the children in $T_{2}$.

Since K is a polynomial kernel algorithm, for every node $(x,k)$ in $T_{2}$ it holds that $|x|\leq s_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(u(k))$, or $(x,k)$ is the root node. This implies that $T_{2}$ is a tree in which every label is polynomially bounded with respect to the parameter. The only exception is the additional term $W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(|x|,k)$ in the label of the root node. It follows that the total work of our algorithm can be estimated by using recurrence equations where the inhomogeneity is a polynomial. Note that this is only possible with the necessary upper bound for the values in the branching vectors.

It remains to show that the work of the interleaving algorithm is $O(\xi_{D}^{k})$ in addition to the application of the kernel, which is bounded by the sum of all labels of $T_{2}$. To prove this, we use the following terminology: We wish to bound values $W_{k}$ for $k\in\mathbb{N}$ for which we know that the following holds:

[TABLE]

where each $d^{k}$ is a branching vector (having length $|d^{k}|$) and $f_{k}\in\mathbb{N}$ are numbers. Let $\xi_{d^{k}}$ be the reciprocal of the minimal root of the polynomial

[TABLE]

and let $\xi=\sup_{d^{k}\in D}\xi_{d^{k}}$. Then we have $\xi_{D}=\xi$.

Define values $U_{k}$ (for “upper bound”) by the recurrence equation

[TABLE]

and $U_{0}=f_{0}$ and observe that this recursion has a unique solution. We prove by induction that

[TABLE]

holds for all $k\in\mathbb{N}$ and all solutions $W_{k}$ of (1). Clearly, the claim holds for $k=0$ since $W_{k}\leq f_{k}=U_{k}$ for $k=0$. For the inductive step, observe that (3) clearly implies $U_{k}\geq\xi U_{k-1}$. Thus $U_{k}\geq\xi^{i}U_{k-i}$ for $i\geq 1$ and, in particular, $U_{k-1}\geq\xi^{i-1}U_{k-i}$, which in turn is equivalent to

[TABLE]

This allows us to bound $W_{k}$ as follows:

[TABLE]

We now know that in order to bound the runtime of the interleaving algorithm, it suffices to solve the recurrence equation $U_{k}=\xi_{D}U_{k-1}+f_{k}$. However, it is well-known that when $f_{k}$ is a polynomial, this has the solution $U_{k}=\lambda\xi_{d}^{k}+p(k)$ for some polynomial $p$ and some for constant $\lambda$, see [14]. Since the labels $W_{2}(x,k)$ in the tree $T_{2}$ are polynomially bounded by $k$, the sum of all labels in $T_{2}$ is $W_{\mathchoice{\text{{K}}}{\text{{K}}}{\text{{K}}}{\text{{K}}}}(n,k)+O(\xi_{D}^{k})$. Finally, this gives us the claimed work for our algorithm. ∎

Note that the search trees arising from the branching rule $\mathchoice{\text{{B}}}{\text{{B}}}{\text{{B}}}{\text{{B}}}_{*}$ always have property (b), that is, they never “parallelize too well” since we capped to size $m$ of $M$ to $(k-|P|)/(s+1)$ and, thus, $k-|P|-|X_{1}|-\cdots-|X_{m}|\geq k-|P|-s(k-|P|)/(s+1)=(k-|P|)/(s+1)$, meaning that we can set $\varepsilon=1/(s+1)$.

6 Conclusion and Outlook

We have begun to extend the field of parallel parameterized algorithms with respect to work-optimality. This is a first step towards the aim of closing the gap between theoretical parallel algorithms (which are fast but produce massive work) and algorithms that work well in practice. To that end we provided a framework that allows to transform sequential search tree algorithms as well as kernelizations into parallel algorithms that are work-efficient. Furthermore, we have shown that combining both techniques via interleaving is still possible in the parallel setting. There are multiple paths to extend this line of research: It would be interesting to know if the presented algorithms do, in fact, lead to competitive parallel implementations. From the theory point of view, a natural next step is to study which other fpt techniques allow work-optimal implementations.