3. Interleaving Hierarchies of Parameterized Incremental Delay
The previous observations raise the question of how
$\mathsf{DelayFPT}$ relates to
$\mathsf{IncFPT}$. In the classical enumeration world, this question has been partially answered by Capelli and Strozecki ([
12], Proposition 16) for a weaker capped version of incremental polynomial time:
$\mathsf{DelayP}\u228a\mathsf{CapIncP}$ is true for the restriction to solution sets that do not necessarily obey the last two items of Definition 3 (they call this class
$\mathrm{Enum}\xb7\mathrm{F}$). Only for linear total time and polynomial space under this setting is the relation not completely understood, that is, the question how
$\mathsf{DelayP}$ with polynomial space relates to
${\mathsf{CapIncP}}_{1}$ with polynomial space ([
12], Open Problem 1, p. 10).
In the course of this chapter, it is shown that the relationship between the classical and the parameterized world is very close. Capelli and Strozecki approach the separation mentioned above through the classes ${\mathsf{CapIncP}}_{a}$ and prove a strict hierarchy of these classes. We lift this to the parameterized setting.
Definition 8 (Sliced Versions of Incremental FPT Delay, extending Definition 7). Let $E=(Q,\kappa ,\mathrm{Sol})$ be a PEP and $\mathcal{A}$ an enumeration algorithm for E. Then, algorithm $\mathcal{A}$ is
 3′.
a ${\mathsf{CapIncFPT}}_{a}$algorithm (for $a\in \mathbb{N}$) if there exists a computable function $t:\mathbb{N}\to \mathbb{N}$ and a polynomial p such that for every $x\in {\Sigma}^{*}$, $\mathcal{A}$ outputs i elements of $\mathrm{Sol}(x)$ in time $t(\kappa (x))\xb7{i}^{a}\xb7p(x)$ (for every $0\le i\le \mathrm{Sol}(x)$).
 3″.
an ${\mathsf{IncFPT}}_{a}$algorithm (for $a\in \mathbb{N}$) if there exists a computable function $t:\mathbb{N}\to \mathbb{N}$ and a polynomial p such that for every $x\in {\Sigma}^{*}$, $\mathcal{A}$ outputs $\mathrm{Sol}(x)$ and its ith delay is at most $t(\kappa (x))\xb7{i}^{a}\xb7p(x)$.
Similarly, we define a hierarchy of classes ${\mathsf{CapIncFPT}}_{a}$ for every $a\in \mathbb{N}$ which consist of problems that admit an ${\mathsf{CapIncFPT}}_{a}$algorithm. Moreover, $\mathsf{CapIncFPT}:={\bigcup}_{a\in \mathbb{N}}{\mathsf{CapIncFPT}}_{a}$.
Clearly, ${\bigcup}_{a\in \mathbb{N}}{\mathsf{IncFPT}}_{a}=\mathsf{IncFPT}$ and ${\mathsf{IncFPT}}_{0}=\mathsf{DelayFPT}$ by Definition 7 as the ith delay then merely is $t(\kappa (x))\xb7p(x)$, as ${i}^{0}=1$.
Usually, one utilizes a priority queue to store the already printed solutions as it allows for efficiently detecting duplicates. Nevertheless, it is unclear how to detect duplicates of solutions without storing them in the queue. Currently, it seems that the price of a “regular” (that is, polynomial) delay then is paid by the need for exponential space. Agreeing with Capelli and Strozecki ([
12], Section 3), it seems very reasonable to see the difference of
${\mathsf{IncFPT}}_{1}$ and
$\mathsf{DelayFPT}$ anchored in the presence of an exponential sized priority queue. However, relaxing this statement shows that the equivalence of incremental
$\mathsf{FPT}$ delay and capped incremental
$\mathsf{FPT}$time is also true in the parameterized world. Similarly, as in the classical setting ([
12], Proposition 12), the benefit of a structured delay can be reached with the exponential space of a priority queue. To lift the argumentation in the proof to the parameterized setting, one needs to keep track of the factors of the kind
$t(\kappa (x))$ in the process. The remainder of the argumentation is the same.
Theorem 1. For every $a\ge 0$, ${\mathsf{CapIncFPT}}_{a+1}={\mathsf{IncFPT}}_{a}$.
Proof. “⊇”: Let
$E=(Q,\kappa ,\mathrm{Sol})$ be a PEP in
${\mathsf{IncFPT}}_{a}$ via an algorithm
$\mathcal{A}$. Let
$t:\mathbb{N}\to \mathbb{N}$ be a computable function and
$p:\mathbb{N}\to \mathbb{N}$ be a polynomial as in Definition 8 (3″). For every
$x\in Q$, algorithm
$\mathcal{A}$ outputs
i solutions with a running time bounded by
Accordingly, we have that $E\in {\mathsf{CapIncFPT}}_{a+1}$.
“⊆”: Now consider a problem
$E=(Q,\kappa ,\mathrm{Sol})\in {\mathsf{CapIncFPT}}_{a+1}$ via
$\mathcal{A}$ enumerating
i elements of
$\mathrm{Sol}(x)$ in time
$\le t(\kappa (x)){i}^{a+1}\xb7p(x)$ for all
$x\in Q$, for all
$0\le i\le \mathrm{Sol}(x)$, and some computable function
t (see Definition 8 (3′)). We show that enumerating
$\mathrm{Sol}(x)$ can be achieved with an
ith delay of
$O(t(\kappa (x))\xb7p(x)\xb7q(i)+s)$, where
$q(i)={(i+1)}^{a+1}{i}^{a+1}$ and
s bounds the solution sizes (which is polynomially in the input length; w.l.o.g. let
p be an upper bound for this polynomial). This means that we argue on the duration of the
ith delay, which summarizes the time needed to find the
ith solution and to print it. To reach this delay, one uses two counters: one for the steps of
$\mathcal{A}$ (steps) and one for the solutions, initialized with value 1 (solindex). While simulating
$\mathcal{A}$, the solutions are inserted into a priority queue
$\mathcal{Q}$ instead of printing them. Eventually, the step counter reaches
$t(\kappa (x))\xb7p(x)\xb7{\mathsf{solindex}}^{a+1}$. Then, the first element of
$\mathcal{Q}$ is extracted, output, and
$\mathsf{solindex}$ is incremented by one. In view of this,
$\mathcal{A}$ computed solindex many solutions and prints the next one (or
$\mathcal{A}$ already halted). Combining these observations leads to calculating the
ith delay:
Clearly, this is a delay of the required form $t(\kappa (x))\xb7p(x)\xb7{i}^{a}$, and thus, $E\in {\mathsf{IncFPT}}_{a}$. □
Note that from the previous result, one can easily obtain the following corollary.
Corollary 2. ${\mathsf{CapIncFPT}}_{1}=\mathsf{DelayFPT}$ and $\mathsf{CapIncFPT}=\mathsf{IncFPT}$.
If one drops the restrictions 3. and 4. from Definition 3, then Capelli and Strozecki unconditionally show a strict hierarchy for the capclasses via utilizing the wellknown time hierarchy theorem [
42]. Of course, this result transfers also to the parameterized world, that is, to the same generalization of
${\mathsf{CapIncFPT}}_{a}$. Nonetheless, it is unknown whether a similar hierarchy can be unconditionally shown for these classes as well as for
${\mathsf{IncFPT}}_{a}$.
Open Problem 1.Can a similar hierarchy be unconditionally shown for these classes as well as for ${\mathsf{IncFPT}}_{a}$?
This is a significant question of further research which is strengthened in the following section via connecting parameterized with classical enumeration complexity.
4. Connecting with Classical Enumeration Complexity
Capelli and Strozecki [
12] 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
$\mathsf{DelayP}$algorithm will yield the price of an increasing
$\mathsf{IncP}$ delay. This remark perfectly reflects with what has been observed by Creignou et al. [
20]. They noticed that outputting solutions ordered by their size seems to require exponential space in case one aims for
$\mathsf{DelayFPT}$. Nonetheless, the mandatory order is a strong additional constraint which might weaken the evidence of that result substantially. As mentioned in the introduction, Meier and Reinbold [
22] observed how a
$\mathsf{DelayFPT}$ algorithm with exponential space of a specific problem is transformed into an
$\mathsf{IncFPT}$ algorithm with polynomial space. These results emphasize what we strive for and why it is valuable to have such a connection between these two enumeration complexity fields. In this section, we prove that a collapse of
$\mathsf{IncP}$ and
$\mathsf{OutputP}$ implies
$\mathsf{OutputFPT}$ collapsing to
$\mathsf{IncFPT}$ and vice versa.
Capelli and Strozecki [
12] 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 optimization, 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 $Q\subseteq {\Sigma}^{*}$ and their solutionspace $\mathcal{S}\subseteq {\Sigma}^{*}$ with relations $\{(x,y)\mid y\in \mathrm{Sol}(x)\}$ and thereby extend the notation of PPs, EPs, and PEPs. Nevertheless, it is easy to see how to utilize a witness function f for a given language L such that $x\in L$ implies $f(x)=y$ for some y such that $A(x,y)$ is true (this means that $(x,y)\in A$ for the kind of relations mentioned before), and $f(x)=$“no” otherwise, in order to match the term “function complexity class” more adequately.
Definition 9. We say that a relation $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ is polynomially balanced if $(x,y)\in A$ implies that $y\le p(x)$ for some polynomial p.
Recall that, for instances of a (P)EP E over $\Sigma $, the length of its solutions is polynomially bounded. Accordingly, the underlying relation $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ is polynomially balanced.
The following two definitions present four function complexity classes.
Definition 10 ($\mathsf{F}\mathsf{P}$ and $\mathsf{F}\mathsf{NP}$). Let $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ be a binary and polynomially balanced relation.
$A\in \mathsf{F}\mathsf{P}$ if there is a deterministic polynomial time algorithm that, given $x\in {\Sigma}^{*}$, can find some $y\in {\Sigma}^{*}$ such that $A(x,y)$ is true.
$A\in \mathsf{F}\mathsf{NP}$ if there is a deterministic polynomial time algorithm that can determine whether $A(x,y)$ is true, given both x and y.
Definition 11 ($\mathsf{F}(\mathsf{FPT})$ and $\mathsf{F}(\mathsf{para}$$\mathsf{NP})$). Let $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ be a parameterized and polynomially balanced relation with parameterization κ.
$A\in \mathsf{F}(\mathsf{FPT})$ if there exists a deterministic algorithm that, given $x\in {\Sigma}^{*}$, can find some $y\in {\Sigma}^{*}$ such that $A(x,y)$ is true and runs in time $f(\kappa (x))\xb7p(x)$, where f is a computable function and p is a polynomial.
$A\in \mathsf{F}(\mathsf{para}$$\mathsf{NP})$ if there exists a deterministic algorithm that, given both x and y, can determine whether $A(x,y)$ is true and runs in time $f(\kappa (x))\xb7p(x)$, where f is a computable function and p is a polynomial.
Note that the definition of $\mathsf{F}(\mathsf{para}$$\mathsf{NP})$ follows the verifier characterization of precomputation on the parameter as observed in Corollary 1. Similarly to the classical decision class, $\mathsf{NP}$, the runtime has to be independent of the witness length $y$.
The next definition lifts the class
$\mathsf{F}(\mathsf{NP}\cap \mathsf{co}\mathsf{NP})$ [
23] to the parameterized setting. Notice that the class definition incorporates two special markers (called
a and
b)—similar as in the classical setting—to differentiate between the two types of witnesses.
Definition 12 ($\mathsf{F}(\mathsf{para}$$\mathsf{NP}\cap \mathsf{para}$$\mathsf{co}\mathsf{NP})$). Given a language $L\subseteq {\Sigma}^{*}$, we say that $L\in \mathsf{F}(\mathsf{para}$$\mathsf{NP}\cap \mathsf{para}$$\mathsf{co}\mathsf{NP})$ if there exist two parameterized and polynomially balanced relations $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ and $B\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ with parameterizations κ and ${\kappa}^{\prime}$ as well as a nondeterministic algorithm N such that the following two properties are fulfilled.
For each $x\in L$, either there exists a y with $(x,ay)\in A$, or there is a z with $(x,bz)\in B$, where $a\ne b$ are two special markers in Σ.
Given $x\in {\Sigma}^{*}$, N can find either a y with $A(x,ay)$ or a z with $B(x,bz)$ in time $f(\kappa (x))\xb7p(x)+g({\kappa}^{\prime}(x))\xb7q(x)$, or state that such ones do not exist, where $p,q$ are polynomials and $f,g$ are computable functions.
The typical problems in
$\mathsf{F}(\mathsf{para}$
$\mathsf{NP}\cap \mathsf{para}$
$\mathsf{co}\mathsf{NP})$ then ask for finding an appropriate witness (of ‘type’ either
a or
b) with respect to a given
x. (
Table 1)
In 1994, Bellare and Goldwasser [
43] investigated functional versions of
$\mathsf{NP}$ problems. They observed that under standard complexitytheoretic assumptions (deterministic doubly exponential time is different from nondeterministic doubly exponential time), such functional variants are not selfreducible (as the decision variant is). Here, a problem is selfreducible means that one constructs a witness in a bitwise fashion, given an oracle for that problem. Bellare and Goldwasser noticed that these functional versions are harder than their corresponding decision variants.
A binary relation $R\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ is said to be total if for every $x\in {\Sigma}^{*}$ there exists a $y\in {\Sigma}^{*}$ such that $(x,y)\in R$.
Definition 13 (Total function complexity classes). $\mathsf{TF}\mathsf{NP}$ (resp., $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})$) is the restriction of $\mathsf{F}\mathsf{NP}$ (resp., $\mathsf{F}(\mathsf{para}$$\mathsf{NP})$) to total relations.
The two previously defined classes are
promise classes in the sense that the existence of a witness
y with
$A(x,y)$ is guaranteed. Furthermore, defining a class
$\mathsf{TF}(\mathsf{P})$ or
$\mathsf{TF}(\mathsf{FPT})$ is not meaningful as it is known that
$\mathsf{F}\mathsf{P}\subseteq \mathsf{TF}\mathsf{NP}$ (see, e.g., the work of Johnson et al. ([
44], Lemma 3) showing that
$\mathsf{F}\mathsf{P}$ is contained in
$\mathsf{PLS}$, polynomial local search, which is contained in
$\mathsf{TF}\mathsf{NP}$ by Megiddo and Papadimitriou ([
23], p. 319). Similar arguments apply to
$\mathsf{F}(\mathsf{FPT})\subseteq \mathsf{TF}(\mathsf{para}$
$\mathsf{NP})$).
Now, we can define a generic (parameterized) search and a generic (parameterized) enumeration problem. Note that the parameter is only relevant for the parameterized counterpart named in brackets.
Problem:  ($\mathsf{para}$AnotherSol_{A}), where $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ 
Input:  $x\in {\Sigma}^{*}$, $S\subseteq {\Sigma}^{*}$. 
Parameter:  $\kappa :{\Sigma}^{*}\to \mathbb{N}$. 
Task:  output y in $Sol(x)\backslash S$, or answer $S\supseteq \mathrm{Sol}(x)$. 
Problem:  ($\mathsf{para}$)EnumA, where $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ 
Input:  $x\in {\Sigma}^{*}$. 
Parameter:  $\kappa :{\Sigma}^{*}\to \mathbb{N}$. 
Output:  output all y with $A(x,y)$. 
The two results of Capelli and Strozecki ([
12], Propositions 7 and 9) which are crucial in the course of this section are restated in the following.
Proposition 3 ([
12], Proposition 7).
Let $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ be a binary relation such that, given $x\in {\Sigma}^{*}$, one can find a y with $A(x,y)$ in deterministic polynomial time. Then the following is true: A
notherS
ol_{A} ∈
$\mathsf{F}\mathsf{P}$ if and only if E
num
$A\in \mathsf{CapIncP}$.
Proposition 4 ([
12], Proposition 9).
$\mathsf{TF}\mathsf{NP}=\mathsf{F}\mathsf{P}$ if and only if $\mathsf{OutputP}=\mathsf{CapIncP}$. In 1991, Megiddo and Papadimitriou studied the complexity class
$\mathsf{TF}\mathsf{NP}$ [
23]. In a recent investigation, Goldberg and Papadimitriou introduced a rich theory around this complexity class that also features several aspects of proof theory [
24]. Megiddo and Papadimitriou prove that the classes
$\mathsf{F}(\mathsf{NP}\cap \mathsf{co}\mathsf{NP})$ and
$\mathsf{TF}\mathsf{NP}$ coincide. Their arguments are easily lifted to the parameterized setting.
Theorem 2. $\mathsf{F}(\mathsf{para}$$\mathsf{NP}\cap \mathsf{para}$$\mathsf{co}\mathsf{NP})=\mathsf{TF}(\mathsf{para}$$\mathsf{NP})$.
Proof. We reformulate the classical proofs of Megiddo and Papadimitriou [
23].
“⊆”: By definition of the class $\mathsf{F}(\mathsf{para}$$\mathsf{NP}\cap \mathsf{para}$$\mathsf{co}\mathsf{NP})$, either there exists a y with $(x,ay)\in A$, or there is a z with $(x,bz)\in B$. As a result, the mapping $(A,B)\mapsto A\cup B$ suffices and $A\cup B$ is total as either of the two witnesses always exists (see Definition 12). Thus, one just needs to guess which of A or B to choose.
“⊇”: the mapping from the total relation A to $(A,\varnothing )$ meets the requirements of $\mathsf{F}(\mathsf{para}$$\mathsf{NP}\cap \mathsf{para}$$\mathsf{co}\mathsf{NP})$ as only one type of witnesses is needed, and for every x, there is a y such that $(x,y)\in A$ as A is total by assumption. □
For the following Lemma 1 (which is the parameterized pendant of Proposition 3) and theorem, we follow the argumentation in the proofs of the classical results (Propositions 3 and 4). They underline the interplay between search and enumeration.
Lemma 1. Let $A\subseteq {\Sigma}^{*}$ be a parameterized problem with parameterization κ. Then,$\mathsf{para}$AnotherSol_{A} ∈ $\mathsf{F}(\mathsf{FPT})$ if and only if $\mathsf{para}$Enum$A\in \mathsf{CapIncFPT}$.
Proof. “⇒”: Let $\mathsf{para}$AnotherSol_{A} ∈ $\mathsf{F}(\mathsf{FPT})$ via some algorithm $\mathcal{A}$. Algorithm 1 shows that $\mathsf{para}$Enum$A\in \mathsf{CapIncFPT}$.
The runtime of each step is $f(\kappa (x))\xb7p(x,S)$ for some polynomial p and some computable function f. Consequently, this shows that $\mathsf{para}$Enum$A\in \mathsf{CapIncFPT}$.
“⇐”: Let $\mathsf{para}$Enum$A\in \mathsf{CapIncFPT}$. Then, there exists a parameterized enumeration algorithm $\mathcal{A}$ that, given input $x\in {\Sigma}^{*}$, outputs $i\le \mathrm{Sol}(x)$ elements in a runtime of $f(\kappa (x))\xb7{i}^{a}\xb7p(x)$ for some computable function f, $a\in \mathbb{N}$, and a polynomial p.
Now, we explain how to compute $\mathsf{para}$AnotherSol_{A} in fpttime. Given $(x,S)$, simulate $\mathcal{A}$ for $f(\kappa (x))\xb7{(S+1)}^{a}\xb7p(x)$ steps. If the simulation successfully halts, then $\mathrm{Sol}(x)$ is completely output. Just search a $y\in \mathrm{Sol}(x)\backslash S$ or output “$S\supseteq \mathrm{Sol}(x)$”. Otherwise, if $\mathcal{A}$ did not halt, then it did output at least $S+1$ different elements. Finally, we just compute $\mathrm{Sol}(x)\backslash S$ and print a new element. □
Algorithm 1: Algorithm showing $\mathsf{para}$Enum$A\in \mathsf{CapIncFPT}$. 

The next theorem translates the result of Proposition 4 from classical enumeration complexity to the parameterized setting. It shows the first connection of parameterized enumeration to parameterized function complexity.
Theorem 3. $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$ if and only if $\mathsf{OutputFPT}=\mathsf{CapIncFPT}$.
Proof. “⇐”: Let
$A\in \mathsf{TF}(\mathsf{para}$
$\mathsf{NP})$ be a parameterized language over
${\Sigma}^{*}\times {\Sigma}^{*}$ with parameterization
$\kappa $. Furthermore, let
M denote the nondeterministic algorithm that guesses the witnesses
y and then verifies with the deterministic algorithm as in Definition 11. Additionally, denote the running time of
M by
$g(\kappa (x))\xb7p(x)$ for a polynomial
p, a computable function
g, and an input
x. Now, define the relation
$C\subseteq {\Sigma}^{*}\times \left\{y\#w\mid y\in {\Sigma}^{*},w\in {\{0,1\}}^{*}\right\}$, where
$\#\notin \Sigma $, such that
Then, for each x there exists $y\#w$ such that $C(x,y\#w)$ is true by the definition of the class $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})$. Moreover, via padding, for each x, there exist at least ${2}^{p(x)}$ solutions z such that $C(x,z)$ is true; in particular, z is of the form $y\#w$ such that $A(x,y)$ is true. Notice that the total length of $y\#w$ is bounded by $g(\kappa (x))\xb7p(x)+p(x)+1$ as y already has the length constraint of $g(\kappa (x))\xb7p(x)$ by the $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})$ requirement. By construction, the trivial bruteforce enumeration algorithm checking all $y\#w$ is in time $g(\kappa (x))\xb7p(x)$ for every element of $\mathrm{Sol}(x)$. Accordingly, this gives $\mathsf{para}$Enum$C\in \mathsf{OutputFPT}$ as the runtime for $\mathsf{OutputFPT}$ algorithms encompasses $\mathrm{Sol}(x)$ as a factor.
Then, $\mathsf{para}$Enum$C\in \mathsf{CapIncFPT}$ and the first $y\#w$ is output in time $g(\kappa (x))\xb7p(x)$. Since A was arbitrary, we conclude with $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$ (as $\mathsf{F}(\mathsf{FPT})\subseteq \mathsf{TF}(\mathsf{para}$$\mathsf{NP})$ by definition).
“⇒”: Consider a problem $\mathsf{para}$Enum$A\in \mathsf{OutputFPT}$ with $\mathsf{para}$Enum$A=(Q,\kappa ,\mathrm{Sol})$. For every $x\in Q$ and $S\subseteq \mathrm{Sol}(x)$ let $D((x,S),y)$ be true if and only if either ($y\in \mathrm{Sol}(x)\backslash S$) or ($y=\#$ and $S\supseteq \mathrm{Sol}(x)$). Then, $D\in \mathsf{TF}(\mathsf{para}$$\mathsf{NP})$:
D is total by construction,
as $\mathsf{para}$Enum$A$ is a PEP, there exists a polynomial q such that for every solution $y\in \mathrm{Sol}(x)$ we have that $y\le q(x)$, and
finally, we need to show that $D((x,S),y)$ can be verified in deterministic time $f(\kappa (x))\xb7p(x,S,y)$ for a computable function f and a polynomial p.
 Case $\mathbf{y}\ne \#$:
$D((x,S),y)$ is true if and only if $y\in \mathrm{Sol}(x)\backslash S$. This requires testing whether $y\notin S$ and $y\in \mathrm{Sol}(x)$. Both can be tested in polynomial time: $p(y,S)$, respectively, $p(x)$ which follows from Definition 7 (4.).
 Case $\mathbf{y}=\#$:
$D((x,S),y)$ is true if and only if $S\supseteq \mathrm{Sol}(x)$. As $\mathsf{para}$Enum$A\in \mathsf{OutputFPT}$, there is a deterministic algorithm $\mathcal{A}$ outputting $\mathrm{Sol}(x)$ in $f(\kappa (x))\xb7p(x,\mathrm{Sol}(x))$ steps. Now, run $\mathcal{A}$ for at most $f(\kappa (x))\xb7p(x,S)$ steps. Then, finishing within this stepsbound implies that $\mathrm{Sol}(x)$ is completely generated, and we merely check $S\supseteq \mathrm{Sol}(x)$ in time polynomial in $S$. If $\mathcal{A}$ did not halt within the stepsbound, we can deduce $\mathrm{Sol}(x)>S$. Accordingly, $S\neg \supseteq \mathrm{Sol}(x)$ follows and $D((x,S),y)$ is not true.
As $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$ is true by precondition, given a tuple $(x,S)$, we either can compute a y with $y\in \mathrm{Sol}(x)\backslash S$ or decide there is none (and then set $y=\#$) in time $f(\kappa (x))\xb7p(x,S,y)$. Accordingly, $\mathsf{para}$AnotherSol_{A} is in $\mathsf{F}(\mathsf{FPT})$ and, by applying Lemma 1, we get $\mathsf{para}$Enum$A$ is in $\mathsf{CapIncFPT}$. This settles that $\mathsf{OutputFPT}=\mathsf{CapIncFPT}$ and concludes the proof. □
The next theorem connects a collapse in the classical function world to a collapse in the parameterized function world. It witnesses the first connection between a collapse in classical and one in parameterized function complexity.
Theorem 4. $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$ if and only if $\mathsf{TF}\mathsf{NP}=\mathsf{F}\mathsf{P}$.
Proof. Let us start with the easy direction.
“⇒”: Let $A\subseteq {\Sigma}^{*}\times {\Sigma}^{*}$ be a total relation in $\mathsf{TF}\mathsf{NP}$. By definition of $\mathsf{TF}\mathsf{NP}$ and $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})$, $(A,{\kappa}_{0})\in \mathsf{TF}(\mathsf{para}$$\mathsf{NP})$, where ${\kappa}_{0}$ is the trivial parameterization assigning to each $x\in {\Sigma}^{*}$ the zero 0. Since $\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$, there exists a computable function $f:\mathbb{N}\to \mathbb{N}$, a polynomial p, and a deterministic algorithm $\mathcal{A}$, that, given the input $x\in {\Sigma}^{*}$, outputs some $y\in {\Sigma}^{*}$ such that $A(x,y)$ in time $f({\kappa}_{0}(x))\xb7p(x)$. As ${\kappa}_{0}(x)=0$ for each x, $f({\kappa}_{0}(x))=f(0)\in \mathbb{N}$ for each x and $\mathcal{A}$ runs in polynomial time. Accordingly, we have $A\in \mathsf{F}\mathsf{P}$ and thereby $\mathsf{F}\mathsf{P}=\mathsf{TF}\mathsf{NP}$ as A was chosen arbitrarily.
“⇐”: Choose some $B\in \mathsf{TF}(\mathsf{para}$$\mathsf{NP})$ via the nondeterministic machine M running in time $f(\kappa (x))\xb7p(x)$ for a polynomial p, a computable function f, a parameterization $\kappa $, and an input x. By Proposition 1, we know that there exists a computable function $\pi :{\Sigma}^{*}\to {\Sigma}^{*}$ and a problem ${B}^{\prime}\subseteq {\Sigma}^{*}\times {\Sigma}^{*}\times {\Sigma}^{*}$ such that ${B}^{\prime}\in \mathsf{F}\mathsf{NP}$ and the following is true: for all instances $x\in {\Sigma}^{*}$ and all solutions $y\in {\Sigma}^{*}$, we have that $(x,y)\in B$ if and only if $\left((x,\pi (\kappa (x)),y\right)\in {B}^{\prime}$.
As
B is total,
${B}^{\prime}$ is total with respect to the third argument as well. It follows by assumption that
${B}^{\prime}$ is also in
$\mathsf{F}\mathsf{P}$ via some deterministic machine
${M}^{\prime}$ having a runtime bounded by a polynomial
q in the input length. Accordingly, we can define a deterministic machine
$\tilde{M}$ for
B which, given input
$x\in {\Sigma}^{*}$, computes
$\pi (\kappa (x))$, then simulates
${M}^{\prime}$ on
$(x,\pi (\kappa (x)))$, and runs in time
where
${f}_{\pi}:{\Sigma}^{*}\to \mathbb{N}$ is a computable function that estimates the runtime of computing
$\pi (\kappa (x))$. Clearly, Equation (
1) is an fptruntime witnessing
$B\in \mathsf{F}(\mathsf{FPT})$. Accordingly, we can deduce that
$\mathsf{TF}(\mathsf{para}$
$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$, as
B was chosen arbitrarily. □
Combining Theorem 3 with Theorem 4 and finally Proposition 4 connects the parameterized enumeration world with the classical enumeration world. The following corollary summarizes deducible connections of parameterized enumeration to classical enumeration, parameterized function complexity, classical function complexity, and decision complexity. This means that a collapse of
$\mathsf{OutputFPT}$ to
$\mathsf{CapIncFPT}$ would yield a collapse of
$\mathsf{TF}\mathsf{NP}$ to
$\mathsf{F}\mathsf{P}$ (Proposition 4) and as well as of
$\mathsf{P}$ to
$\mathsf{NP}\cap \mathsf{co}\mathsf{NP}$ (due to
$\mathsf{TF}\mathsf{NP}=\mathsf{F}(\mathsf{NP}\cap \mathsf{co}\mathsf{NP})$ [
23]).
Corollary 3. The following collapses are equivalent:
$\mathsf{OutputFPT}=\mathsf{CapIncFPT}$
$\mathsf{OutputP}=\mathsf{CapIncP}$
$\mathsf{TF}(\mathsf{para}$$\mathsf{NP})=\mathsf{F}(\mathsf{FPT})$
$\mathsf{TF}\mathsf{NP}=\mathsf{F}\mathsf{P}$
$\mathsf{P}=\mathsf{NP}\cap \mathsf{co}\mathsf{NP}$
If one does not consider space requirements—which is usually the case for these classes—we can deduce the following corollary by applying Corollary 2 and Proposition 2.
Corollary 4. Without space requirements, we have that $\mathsf{OutputFPT}=\mathsf{IncFPT}$ if and only if $\mathsf{OutputP}=\mathsf{IncP}$.
Now, we have seen that the observations made by Capelli and Strozecki [
12] can be directly transferred to the parameterized setting. In cryptography, oneway functions are functions that are easily (in polynomial time) to compute but hard to invert (often, this means either it requires exponential time to invert the function, or, in a probabilistic model, the search space is of exponential size wherefore the success probability to invert the function is very low). A good introduction to this topic is given by Talbot and Welsh [
37]. As a result of Corollary 3 together with Corollary 4, for instance, the existence of oneway functions would separate
$\mathsf{OutputFPT}$ from
$\mathsf{IncFPT}$ as well.