Incremental FPT Delay

: In this paper, we study the relationship of parameterized enumeration complexity classes deﬁned by Creignou et al. (MFCS 2013). Speciﬁcally, we introduce two hierarchies (IncFPTa and CapIncFPTa) of enumeration complexity classes for incremental fpt-time in terms of exponent slices and show how they interleave. Furthermore, we deﬁne several parameterized function classes and, in particular, introduce the parameterized counterpart of the class of nondeterministic multivalued functions with values that are polynomially veriﬁable and guaranteed to exist, TFNP, known from Megiddo and Papadimitriou (TCS 1991). We show that this class TF(para-NP), the restriction of the function variant of NP to total functions, collapsing to F(FPT), the function variant of FPT, is equivalent to the result that OutputFPT coincides with IncFPT. In addition, these collapses are shown to be equivalent to TFNP = FP, and also equivalent to P equals NP intersected with coNP. Finally, we show that these two collapses are equivalent to the collapse of IncP and OutputP in the classical setting. These results are the ﬁrst direct connections of collapses in parameterized enumeration complexity to collapses in classical enumeration complexity, parameterized function and theory.


Enumeration
In 1988, Johnson, Papadimitriou, and Yannakakis [1] laid the cornerstone 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]. Beyond that, recent results unveil major importance in web search, data mining, bioinformatics, and computational linguistics [3]. Moreover, there are connections to formal languages on enumeration problems for probabilistic automata [4].
Clearly, for enumeration algorithms, one is not primarily interested in their runtime complexity, whereas the time elapsed between two consecutive outputs of such an algorithm is of utmost interest. As a result, one measures the delay of such algorithms. The main goal is to achieve a uniform stream of printed solutions. In this context, the complexity class DelayP, that is, polynomial delay, is regarded as an efficient way of enumeration. Enumeration algorithms for problems in that particular class print every p(|x|)-many-steps a new and distinct solution (where x is the input and p is a fixed polynomial). Interestingly, there is exists a class of incremental polynomial delay, IncP, which contains problems that allow for enumeration algorithms whose delay increases in the process of computation. Intuitively, this captures form t(κ(x)) · p(|x|, i), where t is a computable function, κ the parameterization, x the input, and i is the index of the currently printed solution. Similarly, problems in DelayFPT allow for enumeration algorithms running with an fpt-delay.
In their research, Creignou et al. [20] noticed that for some problems, enumerating solutions by increasing size is possible with DelayFPT 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 [22] observed a similar phenomenon. They studied the enumeration complexity of problems in a modern family of logics of dependence and independence. In the context of dependence statements, single assignments do not make sense. As a result, one introduces team semantics defining 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 FPT delay required exponential space in this particular setting. While reaching polynomial space for the same problem, the price was paid by an increasing delay, IncFPT, and it was not clear how to avoid the increase of the delay while maintaining a polynomial space threshold. 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 [12] (see also the discussion in the beginning of Section 4).

Related Work
In 1991, Megiddo and Papadimitriou [23] introduced the function complexity class TFNP and studied problems within this class. In a recent investigation, Goldberg and Papadimitriou introduced a rich theory around this complexity class that also features several aspects of proof theory [24]. Additionally, the investigations of Capelli and Strozecki [12] on probabilistic classes might yield further connections to the enumeration setting via the parameterized analogues of probabilistic computation of Chauhan and Rao [25]. Furthermore, Fichte et al. [26] studied the parameterized complexity of default logic and present in their work a parameterized enumeration algorithm outputting stable extensions. It might be worth further analyzing problems in this setting, possibly yielding IncFPT algorithms. Quite recently, Bläsius et al. [27] considered the enumeration of minimal hitting sets in lexicographical order and devised some cases which allow for DelayP-, resp., DelayFPT-algorithms. Furthermore, Pichler et al. [28] showed enumeration complexity results for problems on MSO (monadic second order logic) formulas. Finally, investigations of Mary and Strozecki [29] are related to the IncP-versus-DelayP question from the perspective of closure operations. Counting classes in the parameterized setting have been introduced by Flum and Grohe [30] as well as by McCartin [31]. Very recently, Roth and Wellnitz [32] presented a thorough study of counting and finding homomorphisms and showed how their results improve the understanding of the class #W [1] (the counting variant of W [1]). The understanding of this class has been improved also by a line of previous research, e.g., the works of Curticapean, Dell, and Roth [33] as well as of Roth and Schmitt [34] (and more recently, together with Dörfler and Wellnitz [35]). The thesis of Curticapean [36] also presents a nice overview of this field.

Our Contribution
We improve the understanding of incremental enumeration time by connecting classical enumeration complexity to the very young field of parameterized enumeration complexity. Although we cannot answer the aforementioned time-space tradeoff question in either a positive or negative way, we hope that the presented "bridge" to parameterized enumeration will be helpful for future research. Capelli and Strozecki [12] distinguished two kinds of incremental polynomial time enumeration, which we call IncP and CapIncP. Essentially, the difference of these two classes lies in the perspective of the delay.
For IncP, one measures the delay between an output solution i and i + 1, which has to be polynomial in i and the input length. For CapIncP, the output of i solutions has to be polynomial in i and the input length. This means that for the latter class, the output stream must not be as uniform as for the former. In Section 4, we introduce several parameterized function classes (a good overview of the classes can be found in Table 1 on page 11) that are utilized to prove our main result: IncFPT = OutputFPT if and only if IncP = OutputP (Corollary 4). This is the first result that directly connects the classical with the parameterized enumeration setting. Through this approach, separating the classical classes then implies separating the parameterized counterparts and vice versa. Moreover, we introduce two hierarchies of parameterized incremental time IncFPT a and CapIncFPT a (where a ∈ N is a class parameter that restricts the exponent of the polynomial for the solution index) in Section 3, show how they interleave and thereby provide some new insights into the interplay of FPT delay and incremental FPT delay. One of the previously mentioned parameterized function classes, TF(para-NP), is a counterpart of the class TFNP, the class of nondeterministic multivalued functions with values that are polynomially verifiable and guaranteed to exist, known from Megiddo and Papadimitriou [23]. For this class, the algorithmic task is to guess a witness y such that (x, y) ∈ A, where A is a total relation. It is important to note that this class summarizes significant cryptography-related problems such as factoring or the discrete logarithm modulo a (certified) prime p of a (certified) primitive root x of p (see the textbook of Talbot and Welsh [37] on cryptography-related problems). Clearly, parameterized versions of these problems are members in TF(para-NP) via trivial parameterization κ one (x) = 1.
Boiling down the presented results yields a list of equivalent collapse results and thereby connects a wealth of different fields of research: parameterized enumeration, classical enumeration, parameterized function complexity, classical function complexity, and computational complexity theory. Our second central result is summarized in Corollary 3 on page 15.

Outline
In Section 2, we introduce the necessary notions of parameterized complexity theory and (parameterized) enumeration algorithms. Then, we continue in Section 3 to present two hierarchies of parameterized incremental FPT enumeration classes and study the relation to DelayFPT. Eventually, in Section 4, we introduce several parameterized function classes and outline connections to the parameterized enumeration classes. There, we connect a collapse of the two function classes TF(para-NP) and F(FPT) to a collapse of OutputFPT and CapIncFPT, extend this collapse to TFNP and FP (thus, in the classical function complexity setting), and further reach out for our main result showing OutputFPT = IncFPT if and only if OutputP = IncP. Finally, we conclude and present questions for future research.

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. [1] or, more recently, of Creignou et al. [38]. For our purposes, polynomially restricted RAMs (RAMs where each register content is polynomially bounded with respect to the input size) suffice. We make use of the standard complexity classes P and NP. An introduction into this field can be found in the textbook of Pippenger [39].

Parameterized Complexity Theory
We present a brief introduction into the field of parameterized complexity theory. For a deeper introduction, we kindly refer the reader to the textbooks of Flum and Grohe [15], Niedermeyer [16], or Downey and Fellows [13].
Let Q ⊆ Σ * be a decision problem over some alphabet Σ. Given an instance x, k ∈ Q × N, we call k the parameter's value (of x). Often, instead of using tuple notation for instances, one uses a polynomial time computable function κ : Σ * → N (the parameterization) to address the parameter's value of an input x. Then, we write (Q, κ) denoting the parameterized problem (PP).
Definition 1 (Fixed-parameter tractable). Let (Q, κ) be a parameterized problem over some alphabet Σ. If there exists a deterministic algorithm A and a computable function f : N → N such that for all x ∈ Σ *

•
A accepts x if and only if x ∈ Q, and • A has a runtime of f (κ(x)) · |x| O(1) , Then A is an fpt-algorithm for (Q, κ) and (Q, κ) is fixed-parameter tractable (or short, in the complexity class FPT).
Flum and Grohe [15] provide a way to "parameterize" a classical and robust complexity class. For our purposes, para-NP suffices, and accordingly, we do not present the general scheme.
Definition 2 (para-NP, ( [15], Definition 2.10)). Let (Q, κ) with Q ⊆ Σ * be a parameterized problem over some alphabet Σ. We have (Q, κ) ∈ para-NP if there exists a computable function f : N → N and a nondeterministic algorithm N such that for all x ∈ Σ * , N correctly decides whether x ∈ Q in at most f (κ(x)) · p(|x|) steps, where p is a polynomial.
Furthermore, Flum and Grohe characterize the class para-NP via all problems "that are in NP after precomputation on the parameter". Proposition 1 ([15], Proposition 2.12). Let (Q, κ) be a parameterized problem over some alphabet Σ. We have (Q, κ) ∈ para-NP if and only if there exists a computable function π : Σ * → Σ * and a problem Q ⊆ Σ * × Σ * such that Q ∈ NP and the following is true: For all instances x ∈ Σ * , we have that x ∈ Q if and only if (x, π(κ(x))) ∈ Q .
According to the well-known characterization of the complexity class NP via a verifier language, one can easily deduce the following corollary, which is later utilized to explain Definition 11. Corollary 1. Let (Q, κ) be a parameterized problem over some alphabet Σ and p some polynomial. We have (Q, κ) ∈ para-NP if there exists a computable function π : Σ * → Σ * and a problem Q ⊆ Σ * × Σ * × Σ * such that Q ∈ P and the following is true: For all instances x ∈ Σ * , we have that x ∈ Q if and only if there exists a y such that |y| ≤ p(|x|) and (x, π(κ(x)), y) ∈ Q .

Enumeration
As already motivated in the beginning of this section, measuring the runtime of enumeration algorithms is usually abandoned beyond the study of OutputP. 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. [1] laid the cornerstone of this intuition in a seminal paper and introduced the necessary tools and complexity notions. Creignou, Olive, and Schmidt [3,40] presented 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 [12] call the corresponding class EnumP). A good textbook that introduces into the field of exact exponential algorithms is by Fomin and Kratsch [41].
there exists a polynomial p such that for all x ∈ Q and y ∈ Sol(x) we have |y| ≤ p(|x|).
Furthermore, we use the shorthand S = x∈Q Sol(x) to refer to the set of solutions for every possible instance. If E = (Q, Sol) is an EP over the alphabet Σ, then we call strings x ∈ Σ * instances of E, and Sol(x) the set of solutions of x.
An enumeration algorithm (EA) A for the EP E = (Q, Sol) is a deterministic algorithm which, on the input x of E, outputs exactly the elements of Sol(x) 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 4 (Delay)
. Let E = (Q, Sol) be an enumeration problem and A be an enumeration algorithm for E. For x ∈ Q, we define the i-th delay of A as the time between outputting the i-th and (i + 1)-st solution in Sol(x). Furthermore, we set the 0-th delay to be the precomputation phase, which is the time from the start of the computation to the first output statement. Analogously, the n-th delay, for n = |Sol(x)|, is the postcomputation phase, which is the time needed after the last output statement until A terminates. If t : N → N, then, generally, A is said to output Sol(x) with delay O(t(|x|)) if for all x ∈ Q and all i ∈ N the i-th delay is in O(t(|x|)).
Subsequently, we use the notion of delay to state the central enumeration complexity classes. Definition 5. Let E = (Q, Sol) be an enumeration problem and A be an enumeration algorithm for E. Then, A is 1.
a P-enum-algorithm if and only if there exists a polynomial p such that for all x ∈ Q, algorithm A outputs a DelayP-algorithm if and only if there exists a polynomial p such that for all x ∈ Q, algorithm A outputs an IncP-algorithm if and only if there exists a polynomial p such that for all x ∈ Q, algorithm A outputs Sol(x) and its i-th delay is in O(p(|x|, i)) (for every a CapIncP a -algorithm if and only if there exists a polynomial p such that for all x ∈ Q, algorithm A outputs i elements of a OutputP-algorithm if and only if there exists a polynomial p such that for all x ∈ Q, algorithm A outputs Then, we say E is in P-enum/DelayP/IncP/CapIncP a /OutputP if E admits an P-enum-/DelayP-/IncP-/ CapIncP a -/OutputP-algorithm. Finally, we define CapIncP := a∈N CapIncP a . Note that in the diploma thesis of Schmidt ([40], Section 3.1), the class P-enum is called TotalP. 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 [12]. Additionally, we want to point out that Capelli and Strozecki use the definition of CapIncP for IncP (and use the name "UsualIncP" for IncP instead). They prove that the notions of CapIncP and IncP are equivalent up to an exponential space requirement when using a structured delay. The idea for the following proposition is that we can wait to output previously computed solutions. Corollary 13). Without any space restrictions we have that CapIncP = IncP.
After studying the definition of the class CapIncP, one could easily come to the opinion that the class is more general than IncP because it does not necessarily have a uniform delay. However, the previous proposition told us that this is not true.

Parameterized Enumeration
Having introduced the basic principles in parameterized complexity theory and enumeration complexity theory, we introduce a combined version of these notions.
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 nonparameterized case from the previous section.

Definition 7 ([19])
. Let E = (Q, κ, Sol) be a PEP and A an enumeration algorithm for E. Then the algorithm A is 1.
an FPT-enumeration algorithm if there exists a computable function t : N → N and a polynomial p such that for every instance x ∈ Σ * , A outputs Sol(x) in time at most t(κ(x)) · p(|x|), 2.
a DelayFPT-algorithm if there exists a computable function t : N → N and a polynomial p such that for every x ∈ Σ * , A outputs Sol(x) with delay of at most t(κ(x)) · p(|x|), 3.
an IncFPT-algorithm if there exists a computable function t : N → N and a polynomial p such that for every x ∈ Σ * , A outputs Sol(x) and its i-th delay is at most t(κ(x)) · p(|x|, i), and 4.
an OutputFPT-algorithm if there exists a computable function t : N → N and a polynomial p such that for Note that, as before, the notion of TotalFPT has been used for the class of FPT-enumerable problems [18]. We avoid this name as it causes confusion with respect to an enumeration class TotalP ( [40], Section 3.1), which takes into account not only the size of the input but also the number of solutions. We call this class OutputP instead and, accordingly, it is the nonparameterized analogue of the above class OutputFPT. Now, we group these different kinds of algorithms in complexity classes.
The class DelayFPT captures a good notion of tractability for parameterized enumeration complexity. Creignou et al. [19] identified a multitude of problems that admit DelayFPT enumeration. Note that, due to Flum and Grohe ( [15], Proposition 1.34) the class FPT can be characterized via runtimes of the form either f (κ(x)) · p(|x|) or f (κ(x)) + p(|x|) (as a · b ≤ a 2 + b 2 , for all a, b ∈ N). Accordingly, this applies also to the introduced classes DelayFPT, IncFPT, and OutputFPT.

Interleaving Hierarchies of Parameterized Incremental Delay
The previous observations raise the question of how DelayFPT relates to 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: DelayP 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 Enum · F). Only for linear total time and polynomial space under this setting is the relation not completely understood, that is, the question how DelayP with polynomial space relates to 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 CapIncP a and prove a strict hierarchy of these classes. We lift this to the parameterized setting. . Let E = (Q, κ, Sol) be a PEP and A an enumeration algorithm for E. Then, algorithm A is 3'. a CapIncFPT a -algorithm (for a ∈ N) if there exists a computable function t : N → N and a polynomial p such that for every x ∈ Σ * , A outputs i elements of Sol(x) in time t(κ(x)) · i a · p(|x|) (for every 0 ≤ i ≤ |Sol(x)|). 3". an IncFPT a -algorithm (for a ∈ N) if there exists a computable function t : N → N and a polynomial p such that for every x ∈ Σ * , A outputs Sol(x) and its i-th delay is at most t(κ(x)) · i a · p(|x|).
Similarly, we define a hierarchy of classes CapIncFPT a for every a ∈ N which consist of problems that admit an CapIncFPT a -algorithm. Moreover, CapIncFPT := a∈N CapIncFPT a .
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 IncFPT 1 and DelayFPT anchored in the presence of an exponential sized priority queue. However, relaxing this statement shows that the equivalence of incremental FPT delay and capped incremental 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(κ(x)) in the process. The remainder of the argumentation is the same. Proof. "⊇": Let E = (Q, κ, Sol) be a PEP in IncFPT a via an algorithm A. Let t : N → N be a computable function and p : N → N be a polynomial as in Definition 8 (3"). For every x ∈ Q, algorithm A outputs i solutions with a running time bounded by Accordingly, we have that E ∈ CapIncFPT a+1 . "⊆": Now consider a problem E = (Q, κ, Sol) ∈ CapIncFPT a+1 via A enumerating i elements of Sol(x) in time ≤ t(κ(x))i a+1 · p(|x|) for all x ∈ Q, for all 0 ≤ i ≤ |Sol(x)|, and some computable function t (see Definition 8 (3')). We show that enumerating Sol(x) can be achieved with an i-th delay of O(t(κ(x)) · p(|x|) · q(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 i-th delay, which summarizes the time needed to find the i-th solution and to print it. To reach this delay, one uses two counters: one for the steps of A (steps) and one for the solutions, initialized with value 1 (solindex). While simulating A, the solutions are inserted into a priority queue Q instead of printing them. Eventually, the step counter reaches t(κ(x)) · p(|x|) · solindex a+1 . Then, the first element of Q is extracted, output, and solindex is incremented by one. In view of this, A computed solindex many solutions and prints the next one (or A already halted). Combining these observations leads to calculating the i-th delay: Clearly, this is a delay of the required form t(κ(x)) · p(|x|) · i a , and thus, E ∈ IncFPT a .
Note that from the previous result, one can easily obtain the following corollary. If one drops the restrictions 3. and 4. from Definition 3, then Capelli and Strozecki unconditionally show a strict hierarchy for the cap-classes via utilizing the well-known time hierarchy theorem [42]. Of course, this result transfers also to the parameterized world, that is, to the same generalization of CapIncFPT a . Nonetheless, it is unknown whether a similar hierarchy can be unconditionally shown for these classes as well as for IncFPT a .

Open Problem 1. Can a similar hierarchy be unconditionally shown for these classes as well as for IncFPT a ?
This is a significant question of further research which is strengthened in the following section via connecting parameterized with classical enumeration complexity.

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 DelayP-algorithm will yield the price of an increasing 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 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 DelayFPT algorithm with exponential space of a specific problem is transformed into an 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 IncP and OutputP implies OutputFPT collapsing to 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 ⊆ Σ * and their solution-space S ⊆ Σ * with relations {(x, y) | y ∈ 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 ∈ L implies f (x) = y for some y such that A(x, y) is true (this means that (x, y) ∈ 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 ⊆ Σ * × Σ * is polynomially balanced if (x, y) ∈ A implies that |y| ≤ p(|x|) for some polynomial p.
Recall that, for instances of a (P)EP E over Σ, the length of its solutions is polynomially bounded. Accordingly, the underlying relation A ⊆ Σ * × Σ * is polynomially balanced.
The following two definitions present four function complexity classes.
• A ∈ FP if there is a deterministic polynomial time algorithm that, given x ∈ Σ * , can find some y ∈ Σ * such that A(x, y) is true. • A ∈ FNP if there is a deterministic polynomial time algorithm that can determine whether A(x, y) is true, given both x and y.
• A ∈ F(FPT) if there exists a deterministic algorithm that, given x ∈ Σ * , can find some y ∈ Σ * such that A(x, y) is true and runs in time f (κ(x)) · p(|x|), where f is a computable function and p is a polynomial. • A ∈ F(para-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 (κ(x)) · p(|x|), where f is a computable function and p is a polynomial.
Note that the definition of F(para-NP) follows the verifier characterization of precomputation on the parameter as observed in Corollary 1. Similarly to the classical decision class, NP, the runtime has to be independent of the witness length |y|.
The next definition lifts the class F(NP ∩ coNP) [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 (F(para-NP ∩ para-coNP)). Given a language L ⊆ Σ * , we say that L ∈ F(para-NP ∩ para-coNP) if there exist two parameterized and polynomially balanced relations A ⊆ Σ * × Σ * and B ⊆ Σ * × Σ * with parameterizations κ and κ as well as a nondeterministic algorithm N such that the following two properties are fulfilled.

•
For each x ∈ L, either there exists a y with (x, ay) ∈ A, or there is a z with (x, bz) ∈ B, where a = b are two special markers in Σ. • Given x ∈ Σ * , N can find either a y with A(x, ay) or a z with B(x, bz) in time f (κ(x)) · p(|x|) + g(κ (x)) · q(|x|), or state that such ones do not exist, where p, q are polynomials and f , g are computable functions.
The typical problems in F(para-NP ∩ para-coNP) then ask for finding an appropriate witness (of 'type' either a or b) with respect to a given x. (Table 1) Table 1. Overview of function complexity classes. In the machine column, 'det.'/'nond.' abbreviates 'deterministic'/'nondeterministic'. In the runtime column, p and q are polynomials, f and g are two computable functions, κ is the parameterization of A, κ is the parameterization of B, and x is the input.

Class
Machine Runtime Constraints either find y with A(x, ay) or z with B(x, bz) In 1994, Bellare and Goldwasser [43] investigated functional versions of NP problems. They observed that under standard complexity-theoretic assumptions (deterministic doubly exponential time is different from nondeterministic doubly exponential time), such functional variants are not self-reducible (as the decision variant is). Here, a problem is self-reducible means that one constructs a witness in a bit-wise 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 ⊆ Σ * × Σ * is said to be total if for every x ∈ Σ * there exists a y ∈ Σ * such that (x, y) ∈ R.
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 TF(P) or TF(FPT) is not meaningful as it is known that FP ⊆ TFNP (see, e.g., the work of Johnson et al. ( [44], Lemma 3) showing that FP is contained in PLS, polynomial local search, which is contained in TFNP by Megiddo and Papadimitriou ([23], p. 319). Similar arguments apply to F(FPT) ⊆ TF(para-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.
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 ⊆ Σ * × Σ * be a binary relation such that, given x ∈ Σ * , one can find a y with A(x, y) in deterministic polynomial time. Then the following is true: ANOTHERSOL A ∈ FP if and only if ENUM-A ∈ CapIncP. In 1991, Megiddo and Papadimitriou studied the complexity class TFNP [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 F(NP ∩ coNP) and TFNP coincide. Their arguments are easily lifted to the parameterized setting. Proof. We reformulate the classical proofs of Megiddo and Papadimitriou [23].
"⊆": By definition of the class F(para-NP ∩ para-coNP), either there exists a y with (x, ay) ∈ A, or there is a z with (x, bz) ∈ B. As a result, the mapping (A, B) → A ∪ B suffices and A ∪ 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, ∅) meets the requirements of F(para-NP ∩ para-coNP) as only one type of witnesses is needed, and for every x, there is a y such that (x, y) ∈ 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 ⊆ Σ * be a parameterized problem with parameterization κ. Then, para-ANOTHERSOL A ∈ F(FPT) if and only if para-ENUM-A ∈ CapIncFPT.
The runtime of each step is f (κ(x)) · p(|x|, |S|) for some polynomial p and some computable function f . Consequently, this shows that para-ENUM-A ∈ CapIncFPT.
"⇐": Let para-ENUM-A ∈ CapIncFPT. Then, there exists a parameterized enumeration algorithm A that, given input x ∈ Σ * , outputs i ≤ Sol(x) elements in a runtime of f (κ(x)) · i a · p(|x|) for some computable function f , a ∈ N, and a polynomial p. Now, we explain how to compute para-ANOTHERSOL A in fpt-time. Given (x, S), simulate A for f (κ(x)) · (|S| + 1) a · p(|x|) steps. If the simulation successfully halts, then Sol(x) is completely output. Just search a y ∈ Sol(x) \ S or output "S ⊇ Sol(x)". Otherwise, if A did not halt, then it did output at least |S| + 1 different elements. Finally, we just compute Sol(x) \ S and print a new element.  Proof. "⇐": Let A ∈ TF(para-NP) be a parameterized language over Σ * × Σ * with parameterization κ. 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(κ(x)) · p(|x|) for a polynomial p, a computable function g, and an input x. Now, define the relation C ⊆ Σ * × y#w | y ∈ Σ * , w ∈ {0, 1} * , where # / ∈ Σ, such that C(x, y#w) if and only if A(x, y) and |w| ≤ p(|x|).
Then, for each x there exists y#w such that C(x, y#w) is true by the definition of the class TF(para-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(κ(x)) · p(|x|) + p(|x|) + 1 as y already has the length constraint of g(κ(x)) · p(|x|) by the TF(para-NP) requirement. By construction, the trivial brute-force enumeration algorithm checking all y#w is in time g(κ(x)) · p(|x|) for every element of Sol(x). Accordingly, this gives para-ENUM-C ∈ OutputFPT as the runtime for OutputFPT algorithms encompasses |Sol(x)| as a factor.

1.
D is total by construction, 2.
as para-ENUM-A is a PEP, there exists a polynomial q such that for every solution y ∈ Sol(x) we have that |y| ≤ q(|x|), and 3.
finally, we need to show that D((x, S), y) can be verified in deterministic time f (κ(x)) · p(|x|, |S|, |y|) for a computable function f and a polynomial p.
Case y = #: D((x, S), y) is true if and only if y ∈ Sol(x) \ S. This requires testing whether y / ∈ S and y ∈ Sol(x). Both can be tested in polynomial time: p(|y|, |S|), respectively, p(|x|) which follows from Definition 7 (4.). Case y = #: D((x, S), y) is true if and only if S ⊇ Sol(x). As para-ENUM-A ∈ OutputFPT, there is a deterministic algorithm A outputting Sol(x) in f (κ(x)) · p(|x|, |Sol(x)|) steps. Now, run A for at most f (κ(x)) · p(|x|, |S|) steps. Then, finishing within this steps-bound implies that Sol(x) is completely generated, and we merely check S ⊇ Sol(x) in time polynomial in |S|. If A did not halt within the steps-bound, we can deduce |Sol(x)| > |S|. Accordingly, S ⊇ Sol(x) follows and D((x, S), y) is not true.
As TF(para-NP) = F(FPT) is true by precondition, given a tuple (x, S), we either can compute a y with y ∈ Sol(x) \ S or decide there is none (and then set y = #) in time f (κ(x)) · p(|x|, |S|, |y|). Accordingly, para-ANOTHERSOL A is in F(FPT) and, by applying Lemma 1, we get para-ENUM-A is in CapIncFPT. This settles that OutputFPT = 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. Proof. Let us start with the easy direction.
"⇒": Let A ⊆ Σ * × Σ * be a total relation in TFNP. By definition of TFNP and TF(para-NP), (A, κ 0 ) ∈ TF(para-NP), where κ 0 is the trivial parameterization assigning to each x ∈ Σ * the zero 0. Since TF(para-NP) = F(FPT), there exists a computable function f : N → N, a polynomial p, and a deterministic algorithm A, that, given the input x ∈ Σ * , outputs some y ∈ Σ * such that A(x, y) in time f (κ 0 (x)) · p(x). As κ 0 (x) = 0 for each x, f (κ 0 (x)) = f (0) ∈ N for each x and A runs in polynomial time. Accordingly, we have A ∈ FP and thereby FP = TFNP as A was chosen arbitrarily.
"⇐": Choose some B ∈ TF(para-NP) via the nondeterministic machine M running in time f (κ(x)) · p(|x|) for a polynomial p, a computable function f , a parameterization κ, and an input x. By Proposition 1, we know that there exists a computable function π : Σ * → Σ * and a problem B ⊆ Σ * × Σ * × Σ * such that B ∈ FNP and the following is true: for all instances x ∈ Σ * and all solutions y ∈ Σ * , we have that (x, y) ∈ B if and only if (x, π(κ(x)), y ∈ B .
As B is total, B is total with respect to the third argument as well. It follows by assumption that B is also in FP via some deterministic machine M having a runtime bounded by a polynomial q in the input length. Accordingly, we can define a deterministic machine M for B which, given input x ∈ Σ * , computes π(κ(x)), then simulates M on (x, π(κ(x))), and runs in time where f π : Σ * → N is a computable function that estimates the runtime of computing π(κ(x)). Clearly, Equation (1) is an fpt-runtime witnessing B ∈ F(FPT). Accordingly, we can deduce that TF(para-NP) = F(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 OutputFPT to CapIncFPT would yield a collapse of TFNP to FP (Proposition 4) and as well as of P to NP ∩ coNP (due to TFNP = F(NP ∩ coNP) [23]). Corollary 3. The following collapses are equivalent: 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. Now, we have seen that the observations made by Capelli and Strozecki [12] can be directly transferred to the parameterized setting. In cryptography, one-way 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 one-way functions would separate OutputFPT from IncFPT as well.

Conclusions and Outlook
We presented the first connection of parameterized enumeration to classical enumeration by showing that a collapse of OutputFPT to IncFPT implies collapsing OutputP to CapIncP and vice versa. While proving this result, we showed equivalences of collapses of parameterized function classes developed in this paper to collapses of classical function classes. In particular, we proved that TF(para-NP) = F(FPT) if and only if TFNP = FP (Theorem 4). The function complexity class TFNP, which has TF(para-NP) as its parameterized counterpart, contains significant cryptography-related problems such as factoring. Furthermore, we studied a parameterized incremental FPT time enumeration hierarchy on the level of exponent slices (Definition 8) and observed that CapIncFPT 1 = DelayFPT (Corollary 2). Additionally, an interleaving of the two hierarchies, IncFPT a and CapIncFPT a , has been shown (Theorem 1). The results of this paper underline that parameterized enumeration complexity is an area worth studies, as there are deep connections to its classical counterpart.
Future research should build on these classes to unveil the presence of exponential space in this setting and give a definite answer to the observed time-space tradeoffs of IncFPT versus DelayFPT. Can the hierarchy IncFPT a introduced and studied in Section 3, be shown strict under similar conditions as Capelli and Strozecki were able to prove (they used the exponential time hypothesis)? Moreover, it would be engaging to study connections from parameterized enumeration to proof theory via the work of Goldberg and Papadimitriou [24]. We want to close with the question of whether there exist intermediate natural problems between F(FPT) and TF(para-NP) which are relevant in some area beyond trivial parameterization κ one (x) = 1.

Conflicts of Interest:
The author declares no conflict of interest.