Enumeration in Incremental FPT-Time

04/20/2018 ∙ by Arne Meier, et al. ∙ uni hannover 0

In this paper, we study the relationship of parametrised enumeration complexity classes defined by Creignou et al. (MFCS 2013). Specifically, we introduce a hierarchy of enumeration complexity classes for incremental fpt-time and relate it to the class DelayFPT. Furthermore, we define several parametrised function classes and, in particular, introduce the parametrised counterpart of the class of nondeterministic multivalued functions with values that are polynomially verifiable and guaranteed to exist, TFNP, known from Megiddo and Papadimitriou (TCS 1991). We show that TF(para-NP) collapsing to F(FPT) is equivalent to OutputFPT coinciding with IncFPT. This result is in turn connected to a collapse in the classical function setting and eventually to the collapse of IncP and OutputP which proves the first direct connection of classical to parametrised enumeration.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction


In 1988, Johnson, Papadimitriou and Yannakakis [23] introduced the framework of enumeration algorithms. In modern times of ubiquitous computing, such algorithms are of central importance in several areas of life and research such as combinatorics, computational geometry, and operations research [2]. Also, recent results unveil major importance in web search, data mining, bioinformatics, and computational linguistics [12]. Moreover, there exist connections to formal languages on enumeration problems for probabilistic automata [32].

Clearly, for enumeration algorithms the runtime complexity is rather peripheral and the time elapsed between two outputs is of utmost interest. As a result, one measures the delay of such algorithms and tries to achieve a uniform stream of printed solutions. In this context, the complexity class , that is polynomial delay, is regarded as an efficient way of enumeration. Interestingly, there exists a class of incremental polynomial delay, , which contains problems that allow for enumeration algorithms whose delay increases in the process of computation. Intuitively, this captures the idea that after printing ‘obvious’ solutions, later in the process it becomes difficult to find new outputs. More precisely, the delay between output and is bounded by a polynomial of the input length and of . Consequently, in the beginning, such an algorithm possesses a polynomial delay whereas later it eventually becomes exponential (for problems with exponential many solutions; which is rather a common phenomenon). While prominent problems in the class are the enumeration of satisfying assignments for Horn or Krom formulas [7], structures for first-order query problems with possibly free second-order variables and at most one existential quantifier [15], or cycles in graphs [30], rather a limited amount of research has been invested in understanding . A well-studied problem in this enumeration complexity class is the task of generating all maximal solutions of systems of equations modulo 2 [24]. Even today, it is not clear whether this problem can be solved with a polynomial delay. Other examples for problems in are given by Eiter et al. [16], or Fredman and Khachiyan [19]. Recently, Capelli and Strozecki [5] deeply investigate and its relationship to other classical enumeration classes, improving the overall understanding of this class.

Parametrised Complexity.

The framework of parametrised complexity [14, 13, 18, 28] allows one to approach a fine-grained complexity analysis of problems beyond classical worst-case complexity. Here, one considers a problem together with a parameter and tries to achieve deterministic runtimes of the form , where is the value of the parameter of an instance , is a polynomial, and is an arbitrary computable function. The mentioned runtime is eponymous for the class . As usually a parameter is seen do be slowly growing or even of constant value [1], accordingly, one calls such problems fixed-parameter tractable.

A rather large parametrised complexity class is , the nondeterministic counterpart of , which is defined via nondeterministic runtimes of the same form . Clearly, is true, but essentially is widely not seen as a correspondent of on the classical complexity side. In fact, is the class which usually is used to show intractability lower bounds in the parametrised setting. This class is part of an infinite -hierarchy in between the aforementioned two classes. It is not known whether any of the inclusions of the intermediate classes is strict or not.

Parametrised Enumeration.

Recently, Creignou et al. [10, 11, 9] developed a framework of parametrised enumeration allowing for fine-grained complexity analyses of enumeration problems. In analogue to classical enumeration complexity, there are the classes and , and, here as well, it is unknown if is true or not.

In their research, Creignou et al. [9] noticed that for some problems, enumerating solutions by increasing size is possible with and exponential space (such as triangulations of graphs, or cluster editings). However, it is not clear how to circumvent the unsatisfactory space requirement. Recently, Meier and Reinbold [27] observed a similar phenomenon. They study the enumeration complexity of problems in a modern family of logic of dependence and independence. In the context of dependence statements, single assignments do not make sense. As a result, one introduces team semantics which defines semantics with respect to sets of assignments, which are commonly called teams. Meier and Reinbold showed that in the process of enumerating satisfying teams for formulas of a specific Dependence Logic fragment, it seemed that an delay required exponential space. While reaching polynomial space for the same problem, the price was paid by an increasing delay, , and it was not clear how to avoid the increase of the delay while maintaining polynomial space. This is a significant question of research and we improve the understanding of this question by pointing out connections to classical enumeration complexity where similar phenomena have been observed [5].

Related work.

In 1991, Megiddo and Papadimitriou [26] introduced the function complexity class and studied problems within this class. In a recent investigation, Goldberg and Papadimitriou introduced a rich theory around this complexity class that features also several aspects of proof theory [20]. Also, the investigations of Capelli and Strozecki [5] on probabilistic classes might yield further connections to the enumeration setting via the parametrised analogues of probabilistic computation of Chauhan and Rao [6]. Furthermore, Fichte et al. [17] study the parametrised complexity of default logic and present in their work a parametrised enumeration algorithm outputting stable extensions. It might be worth to further analyse problems in this setting possibly yielding algorithms. Quite recently, Bläsius et al. [4] consider the enumeration of minimal hitting sets in lexicographical order and devise some cases which allow for -, resp., -algorithms. Furthermore, there exists a work in which enumeration complexity results have been made for problems on MSO formulas [29]. Finally, investigations of Mary and Strozecki [25] are related to the -versus- question from the perspective of closure operations.


We improve the understanding of incremental enumeration time by connecting classical enumeration complexity to the very young field of parametrised enumeration complexity. Although we cannot answer the aforementioned time-space-tradeoff question in either positive or negative way, the presented “bridge” to parametrised enumeration will be helpful for future research. Capelli and Strozecki [5] distinguish two kinds of incremental polynomial time enumeration, which we later will call and . Essentially, the difference of these two classes lies in the perspective of the delay. For one measures the delay between an output solution and which has to be polynomial in and the input length. For the output of solutions has to be polynomial in and the input length. In Section 4, we will introduce several parametrised function classes that are utilised to prove our main result: if and only if . This is the first result that directly connects the classical with the parametrised enumeration setting. By this approach, separating the classical classes then implies separating the parametrised counterparts and vice versa. Moreover, we introduce two hierarchies of parametrised incremental time and in Section 3, show that they interleave and thereby provide some new insights into the interplay of delay and incremental delay. One of the previously mentioned parametrised function classes is a counterpart of the class , the class of nondeterministic multivalued functions with values that are polynomially verifiable and guaranteed to exist, known from Megiddo and Papadimitriou [26]. This class summarises significant cryptography related problems such as factoring or the discrete logarithm modulo a (certified) prime of a (certified) primitive root of . Clearly, parametrised versions of these problems are members in via the trivial parametrisation .


In Section 2, we introduce the necessary notions of parametrised complexity theory and enumeration. Then, we continue in Section 3 to present two hierarchies of parametrised incremental enumeration classes and study the relation to . Eventually, in Section 4, we introduce several parametrised function classes and outline connections to the parametrised enumeration classes. There, we connect a collapse of the two function classes and to a collapse of and , extend this collapse to and (so in the classical function complexity setting), and further reach out for our main result showing if and only if . Finally, we conclude and present questions for future research.

2 Preliminaries

Enumeration algorithms are usually running in exponential time as the solution space is of this particular size. As Turing machines cannot access specific bits of exponentially sized data in polynomial time, one commonly uses the RAM model as the machinery of choice; see, for instance, the work of Johnson et al. 

[23], or more recently, of Creignou et al. [8]. For our purposes, polynomially restricted RAMs (RAMs where each register content is polynomially bounded with respect to the input size) suffice. We will make use of the standard complexity classes and .

2.1 Parametrised Complexity Theory

We will present a brief introduction into the field of parametrised complexity theory. For a deeper introduction we kindly refer the reader to the textbook of Flum and Grohe [18].

Let be a decision problem over some alphabet . Given an instance , we call the parameter’s value (of ). Often, instead of using tuple notation for instances, one uses a polynomial time computable function (the parametrisation) to address the parameter’s value of an input . Then, we write denoting the parametrised problem (PP). Often, the codomain of parametrisations is the natural numbers.

Definition 1 (Fixed-parameter tractable)

Let be a parametrised problem over some alphabet . If there exists a deterministic algorithm and a computable function such that for all

  • accepts if and only if , and

  • has a runtime of ,

then is an fpt-algorithm for and is fixed-parameter tractable (or short, in the complexity class ).

Flum and Grohe [18] provide a way to “parametrise” a classical and robust complexity class. For our purposes suffice and accordingly we do not present the general scheme.

Definition 2 (, [18, Def. 2.10])

Let with be a parametrised problem over some alphabet . We have if there exists a computable function and a nondeterministic algorithm such that for all , correctly decides whether in at most steps, where is a polynomial.

Furthermore, Flum and Grohe characterise the class via all problems “that are in after precomputation on the parameter”.

Proposition 3 (Prop. 2.12 in [18])

Let be a parametrised problem over some alphabet . We have if there exists a computable function and a problem such that and the following is true: for all instances we have that if and only if .

According to the well-known characterisation of the complexity class via a verifier language, one can easily deduce the following corollary which later is utilised to explain Definition 16.

Corollary 4

Let be a parametrised problem over some alphabet and some polynomial. We have if there exists a computable function and a problem such that and the following is true: for all instances we have that if and only if there exists a such that and .

2.2 Enumeration

As already motivated in the beginning of this section, measuring the runtime of enumeration algorithms is usually abandoned. As a result, one inspects the uniformity of the flow of output solutions of these algorithms rather than their total running time. In view of this, one measures the delay between two consecutive outputs. Johnson et al. [23] laid the cornerstone of this intuition in a seminal paper and introduced the necessary tools and complexity notions. Creignou, Olive, and Schmidt [12, 31] present recent notions in this framework, which we aim to follow. In this paper, we only consider enumeration problems which are “good” in the sense of polynomially bounded solution lengths and polynomially verifiable solutions (Capelli and Strozecki [5] call the corresponding class EnumP).

Definition 5 (Enumeration problem)

An enumeration problem (EP) over an alphabet is a tuple , where

  1. is the set of instances (recognisable in polynomial time),

  2. is a computable function such that for all , is a finite set and if and only if ,

  3. , and

  4. there exists a polynomial such that for all and we have .

Furthermore, we use the shorthand to refer to the set of solutions for every possible instance. If is an EP over the alphabet , then we call strings instances of , and the set of solutions of .

An enumeration algorithm for the enumeration problem is a deterministic algorithm which, on the input of , outputs exactly the elements of without duplicates, and which terminates after a finite number of steps on every input.

The following definition fixes the ideas of measuring the ‘flow of output solutions’.

Definition 6 (Delay)

Let be an enumeration problem and be an enumeration algorithm for . For we define the -th delay of as the time between outputting the -th and -st solution in . Furthermore, we set the -th delay to be the precomputation phase which is the time from the start of the computation to the first output statement. Analogously, the -th delay, for , is the postcomputation phase which is the time needed after the last output statement until terminates.

Subsequently, we will use the notion of delay to state the central enumeration complexity classes.

Definition 7

Let be an enumeration problem and be an enumeration algorithm for . Then is

  1. an -algorithm if and only if there exists a polynomial such that for all , algorithm outputs in time .

  2. a -algorithm if and only if there exists a polynomial such that for all , algorithm outputs with delay .

  3. an -algorithm if and only if there exists a polynomial such that for all , algorithm outputs and its -th delay is in (for every ).

  4. a -algorithm if and only if there exists a polynomial such that for all , algorithm outputs elements of in time (for every .

  5. a -algorithm if and only if there exists a polynomial such that for all , algorithm outputs in time .

Accordingly, we say is in //// if admits an -/-/-/-/-algorithm. Finally, we define .

Note that in the diploma thesis of Schmidt [31, Sect. 3.1] the class is called . We avoid this name to prevent possible confusion with class names defined in the following section as well as with the work of Capelli and Strozecki [5]. Also, we want to point out that Capelli and Strozecki use the definition of for (and use the name “UsualIncP” for instead). They prove that the notions of and are equivalent up to an exponential space requirement when using a structured delay. So generally, without any space restrictions, the following result applies.

Proposition 8 (Corollary 13 in [5])


2.3 Parametrised Enumeration

After we introduced the basic principles in parametrised complexity theory and enumeration complexity theory, we will introduce a combined version of these previously introduced notions.

Definition 9 ([11])

A parametrised enumeration problem (PEP) over an alphabet is a triple where

  • is a parametrisation (that is, a polynomial-time computable function), and

  • is an EP.

Besides, the definitions of enumeration algorithms and delays are easily lifted to the setting of PEPs.

Observe that the following defined classes are in complete analogy to the non-parametrised case from the previous section.

Definition 10 ([11])

Let be a PEP and an enumeration algorithm for . Then the algorithm is

  1. an -enumeration algorithm if there exist a computable function and a polynomial such that for every instance , outputs in time at most ,

  2. a -algorithm if there exist a computable function and a polynomial such that for every , outputs with delay of at most ,

  3. an -algorithm if there exist a computable function and a polynomial such that for every , outputs and its -th delay is at most , and

  4. an -algorithm if there exist a computable function and a polynomial such that for every instance , outputs in time at most .

Note that as before, the notion of has been used for the class of -enumerable problems [10]. We avoid this name as it causes confusion with respect to an enumeration class [31, Sect. 3.1] which takes into account not only the size of the input but also the number of solutions. We call this class instead and accordingly it is the non-parametrised analogue of the above class . Now we group these different kinds of algorithms in complexity classes.

The class /// is the class of all PEPs that admit a -enumeration/-/-/-algorithm.

The class captures a good notion of tractability for parametrised enumeration complexity. Creignou et al. [11] identified a multitude of problems that admit enumeration. Note that, due to Flum and Grohe [18, Prop. 1.34] the class can be characterised via runtimes of the form either or (as , for all ). Accordingly, this applies also to the introduced classes , , and .

3 Interleaving Hierarchies of Parametrised Incremental Time

The previous observations raise the question on how relates to . In the classical enumeration world, this question is answered by Capelli and Strozecki [5, Prop. 16] for the capped version of incremental polynomial time: is true, only for linear total time and polynomial space it has not been answered yet. This is the question how with polynomial space relates to with polynomial space [5, Open Problem 1, p.10]. In the course of this chapter, we will realise that the relationship between the classical and the parametrised world is very close. Capelli and Strozecki approach the separation mentioned above through the classes and prove a strict hierarchy of these classes. We lift this to the parametrised setting.

Definition 11 (Sliced Versions of Incremental FPT, extending Def. 10)
  1. an -algorithm (for ) if there exists a computable function and a polynomial such that for every , outputs elements of in time (for every ).

  2. an -algorithm (for ) if there exists a computable function and a polynomial such that for every , outputs and its -th delay is at most .

Similarly, we define a hierarchy of classes for every which consist of problems that admit an -algorithm. Moreover, .

Clearly, and by Definition 10 as the -th delay then merely is , as .

Agreeing with Capelli and Strozecki [5, Sect. 3], it seems very reasonable to see the difference of and anchored in the exponential sized priority queue. The price of a “regular” (that is, polynomial) delay is paid by requiring exponential space. Though, relaxing this statement shows that the equivalence of incremental delay and capped incremental -time is also true in the parametrised world. Similarly, as in the classical setting [5, Prop. 12], the price of a structured delay is the required exponential space of a priority queue.

Theorem 12

For every , .


’: Let be a PEP in via an algorithm . Let be a computable function and be a polynomial as in Definition 11 (3”.). For every algorithm outputs solutions with a running time bounded by

Accordingly, we have that .

’: Now consider a problem via enumerating elements of in time for all , for all , and some computable function (see Definition 11 (3’.)). We will show that enumerating can be achieved with an -th delay of where and bounds the solution sizes (which is polynomially in the input length; w.l.o.g. let be an upper bound for this polynomial). To reach this delay, one uses two counters: one for the steps of (steps) and one for the solutions, initialised with value (solindex). While simulating , the solutions are inserted into a priority queue instead of printing them. Eventually the step counter reaches . Then the first element of is extracted, output and solindex is incremented by one. In view of this, computed solindex many solutions and prints the next one (or already halted). Combining these observations leads to calculating the -th delay:

Clearly, this is a delay of the required form , and thereby .

Note that from the previous result one can easily obtain the following corollary.

Corollary 13

and .

If one drops the restrictions 3. and 4. from Definition 5, then Capelli and Strozecki unconditionally show a strict hierarchy for the cap-classes via utilising the well-known time hierarchy theorem [21]. Of course, this result transfers also to the parametrised world, that is, to the same generalisation of . Yet it is unknown whether a similar hierarchy can be unconditionally shown for these classes as well as for . This is a significant question of further research which is strengthened in the following section via connecting parametrised with classical enumeration complexity.

4 Connecting with Classical Enumeration Complexity

Capelli and Strozecki [5] ask whether a polynomial delay algorithm using exponential memory can be translated into an output polynomial or even incremental polynomial algorithm requiring only polynomial space. This question might imply a time-space-tradeoff, that is, avoiding exponential space for a -algorithm will yield the price of an increasing delay. This remark perfectly contrasts with what has been observed by Creignou et al. [9]. They noticed that outputting solutions ordered by their size seems to require exponential space in case one aims for . As mentioned in the introduction, Meier and Reinbold [27] observed how a algorithm with exponential space or a specific problem is transformed into an algorithm with polynomial space. These results emphasise why we strive for and why it is valuable to have such a connection between these two enumeration complexity fields. In this section, we will prove that a collapse of and implies collapsing to and vice versa.

Capelli and Strozecki [5]

investigated connections from enumeration complexity to function complexity classes of a specific type. The classes of interest contain many notable computational problems such as integer factoring, local optimisation, or binary linear programming.

It is well known that function variants of classical complexity classes do not contain functions as members but relations instead. Accordingly, we formally identify languages and their solution-space with relations and thereby extend the notation of PPs, EPs, and PEPs. Nevertheless, it is easy to see how to utilise a witness function for a given language such that implies for some such that is true, and “no” otherwise, in order to match the term “function complexity class” more adequately.

Definition 14

We say that a relation is polynomially balanced if implies that for some polynomial .

Observe that, for instances of a (P)EP over , the length of its solutions are polynomially bounded. Accordingly, the underlying relation is polynomially balanced.

The following two definitions present four function complexity classes.

Definition 15 ( and )

Let be a binary and polynomially balanced relation.

  • if there is a deterministic polynomial time algorithm that, given , can find some such that is true.

  • if there is a deterministic polynomial time algorithm that can determine whether is true, given both and .

Definition 16 ( and )

Let be a parametrised and polynomially balanced problem with parametrisation .

  • if there exists a deterministic algorithm that, given , can find some such that is true and runs in time , where is a computable function and is a polynomial.

  • if there exists a deterministic algorithm that, given both and , can determine whether is true and runs in time , where is a computable function and is a polynomial.

Note that the definition of follows the verifier characterisation of precomputation on the parameter as observed in Corollary 4. Similarly to the classical decision class, , the runtime has to be independent of the witness length .

Definition 17 ()

Let and be two parametrised and polynomially balanced problems with parametrisations and satisfying the following requirement: for each either there exists a with , or there is a with , where are two special markers in . We say that, if there exists a nondeterministic algorithm that, given , can find a with or a with in time , where are polynomials and are computable functions.

Class machine runtime constraints
det. find s.t. 
nond. guess s.t. 
nond. guess s.t. ,
is total
det. parametrisation,
find s.t. 
nond. parametrisation,
guess s.t. 
nond. parametrisation,
guess s.t. ,
is total
nond. relations with parametrisations and , either find with or with
Table 1: Overview of function complexity classes. In the machine column ‘det.’/‘nond.’ abbreviates ‘deterministic’/‘nondeterministic’. In the runtime column and are polynomials, and are two computable functions, is the parameter, and is the input.

In 1994, Bellare and Goldwasser [3] investigated functional versions of problems. They observed that under standard complexity-theoretic assumptions (deterministic doubly exponential time is different from nondeterministic doubly exponential time) these problems are not self-reducible. Bellare and Goldwasser noticed that these functional versions are harder than their corresponding decision variants.

A binary relation is said to be total if for every there exists a such that .

Definition 18 (Total function complexity classes)

The class , resp., , is the restriction of , resp., , to total relations.

The two previously defined classes are promise classes in the sense that the existence of a witness with is guaranteed. Furthermore, defining a class or is not meaningful as it is known that (see, e.g., the work of Johnson et al. [22, Lemma 3] showing that is contained in , polynomial local search, which is contained in by Megiddo and Papdimitriou [26, p. 319]). Similar arguments apply to ).

Now, we can define a generic (parametrised) search and a generic (parametrised) enumeration problem. Note that the parameter is only relevant for the parametrised counterpart named in brackets.

Problem: (), where
Input: , .
Parameter: .
Task: output in , or answer .
Problem: (), where
Input: .
Parameter: .
Output: output all with .

The two results of Capelli and Strozecki [5, Prop. 7 and 9] which are crucial in the course of this section are restated in the following.

Proposition 19 (Prop. 7 in [5])

Let be a binary relation such that, given , one can find a with in deterministic polynomial time. if and only if .

Proposition 20 (Prop. 9 in [5])

if and only if .

In 1991, Megiddo and Papadimitriou studied the complexity class [26]. In a recent investigation, Goldberg and Papadimitriou introduced a rich theory around this complexity class that features also several aspects of proof theory [20]. Megiddo and Papadimitriou prove that the classes and coincide. It is easily lifted to the parametrised setting.

Theorem 21



We restate the classical proofs of Megiddo and Papadimitriou [26].

”: By definition of the class , either there exists a with , or there is a with . As a result, the mapping suffices and is total. So we just need to guess which of or to choose. “”: the mapping is obvious.

For the subsequently lemma (which is the parametrised pendant of Prop. 19) and theorem we follow the argumentation in the proofs of the classical results (Prop. 19 and 20).

Lemma 22

Let be a parametrised problem with parametrisation . Then, if and only if .


”: Let via some algorithm . Algorithm 1 shows that .

1 ;
2 repeat
3       ;
4       ;
5       print ;
7until ;
Algorithm 1 Algorithm showing .

The runtime of each step is for some polynomial and some computable function . Consequently, this shows that .

”: Let . Then, there exists a parametrised enumeration algorithm that, given input , outputs elements in a runtime of for some computable function , , and polynomial .

Now, we explain how to compute in fpt-time. Given , simulate for steps. If the simulation successfully halts then is completely output. Just search a or output “”. Otherwise, if did not halt then it did output at least different elements. Finally, we just compute and print a new element.

The next theorem translates the result of Proposition 20 from classical enumeration complexity to the parametrised setting.

Theorem 23

if and only if .


”: Let be a parametrised language over with parametrisation and be the corresponding nondeterministic algorithm running in time for a polynomial , a computable function , and input . Now, define the relation such that

Then for each there exists such that is true by definition of

. Moreover, via padding, for each

, there exist at least solutions such that is true; in particular, is of the form such that is true. By construction, the trivial brute-force enumeration algorithm checking all is in fpt-time for every element of . Accordingly, this gives as the runtime for algorithms encompasses as a factor.

Then and the first is output in fpt-time. Since was arbitrary, we conclude with (as by definition).

”: Consider a problem with . For every and let be true if and only if either () or ( and ). Then :

  1. is total by construction,

  2. as is a parametrised enumeration problem, there exists a polynomial such that for every solution we have , and

  3. finally, we need to show that can be verified in deterministic time for a computable function and a polynomial .

    Case :

    is true if and only if . This requires testing whether and . Both can be tested in polynomial time: , respectively, which follows from Def. 9 (4.).

    Case :

    is true if and only if . As there is an algorithm outputting in steps. Now, run for at most steps. Then finishing within this steps-bound implies that is completely generated and we merely check in time polynomial in . If did not halt within the steps-bound we can deduce . Accordingly, follows and is not true.

As is true by precondition, given a tuple , we either can compute a with or decide there is none (and then set ) in fpt-time. Accordingly, is in and, by applying Lemma 22, we get is in . This settles that and concludes the proof.

The next theorem builds on previous statements in order to connect a collapse in the classical function world to a collapse in the parametrised function world.

Theorem 24

if and only if .


Let us start with the easy direction.

”: Let be a total relation in . By definition of and , where is the trivial parametrisation assigning to each the empty string . Since , there exists a computable function , a polynomial , and a deterministic algorithm , that, given the input , outputs some such that in time . As for each , runs in polynomial time. Accordingly, we have and thereby as was chosen arbitrarily.

”: Choose some via machine running in time for a polynomial , a computable function , a parametrisation , and an input . By Proposition 3, we know that there exists a computable function and a problem such that and the following is true: for all instances and all solutions , we have that if and only if .

As is total, is total with respect to the third argument as well. It follows by assumption that is also in via some machine having a runtime bounded by a polynomial in the input length. Accordingly, we define a machine for which, given input , computes , then simulates on , and runs in time



is a computable function that estimates the runtime of computing

. Clearly, Equation (4) is an fpt-runtime witnessing . Accordingly, we can deduce that