Synchronizing words and monoid factorization, yielding a new parameterized complexity class?

Abstract The concept of a synchronizing word is a very important notion in the theory of finite automata. We consider the associated decision problem to decide if a given DFA possesses a synchronizing word of length at most k, where k is the standard parameter. We show that this problem DFA-SW is equivalent to the problem Monoid Factorization introduced by Cai, Chen, Downey, and Fellows. Apart from the known 
$\textsf{W}[2]$
 -hardness results, we show that these problems belong to 
$\textsf{A}[2]$
 , 
$\textsf{W}[\textsf{P}],$
 and 
$\textsf{WNL}$
 . This indicates that DFA-SW is not complete for any of these classes, and hence, we suggest a new parameterized complexity class 
$\textsf{W}[\textsf{Sync}]$
 as a proper home for these (and more) problems. We present quite a number of problems that belong to 
$\textsf{W}[\textsf{Sync}]$
 or are hard or complete for this new class.

Therefore, it is also interesting to compute a shortest synchronizing word. Unfortunately, as it was shown by Rystsov (1980) and Eppstein (1990), the corresponding decision problem DFA-SW (defined in the following) is NP-complete. Possible applications of this problem are explained in Kisielewicz et al. (2015). The problem has also been considered from the viewpoint of approximation by Berlinkov (2014) and parameterized complexity by Bruchertseifer and Fernau (2021), Fernau et al. (2015), Fernau and Krebs (2017), Montoya and Nolasco (2018).

DFA-SYNCHRONIZING WORD (DFA-SW)
Input: DFA A, k ∈ N Problem: Is there a synchronizing word w for A with |w| ≤ k?
It is important to note at this point that we are working with complete DFAs in our definition; that is, a DFA can be specified as A = (Q, , δ, q 0 , F), where Q is the finite-state alphabet, is the finite input alphabet, δ : Q × → Q is the complete transition function, and q 0 ∈ Q and F ⊆ Q specify the start state and the final state set that are actually inessential for the task of synchronization. While DFA-SW is NP-complete, the complexity picture actually changes if we allow undefined transitions (i.e., if we move over to partial DFAs); the corresponding synchronization problem then becomes PSPACE-complete; see Martyugin (2014). In fact, also based on the mentioned numerous applications of synchronizing automata, many variations have been studied. Here, we only mention some recent papers as , , Wolf (2020). However, we will mostly restrict our attention to the most classical variant of synchronizing automata in this paper.
We will continue to study the problem (DFA-SW) from the point of parameterized complexity. The standard parameter for this problem is the length upper bound k. Also with future definitions of parameterized problems, we will follow the convention that k always denotes the parameter. As the synchronizability of DFAs can be checked in polynomial time (see Sandberg 2005;Volkov 2008) and due to the polynomial upper bound on a shortest synchonizing word (if existent) as discussed above, we can assume that the parameter k is given in unary or binary, whatever is more convenient to us. It was shown in Bruchertseifer and Fernau (2021), Fernau et al. (2015), Montoya and Nolasco (2018) that this problem is W[2]-hard, even when restricted to quite particular (and restricted) forms of finite automata.
Also, other parameters have been studied, in particular, in Fernau et al. (2015), but they are of less interest to the present study where we focus on the standard parameter.

Organization of the Paper and Main Results
In Section 3, we introduce some basic notions of parameterized complexity. Observe that we pay special attention to some complexity classes like A [2] or WNL that are less studied in the literature. Most problems that we look at are W[2]-hard, but in our opinion, from a complexity theoretic viewpoint, an exact classification of parameterized problems should be at least attempted, beyond stating that they are W[1]-hard and hence most likely outside FPT. In Section 4, we focus on studying (DFA-SW), a problem already defined in the introduction; here, our focus is on the length upper bound k as a parameter. As we can see in Section 5, there are several problems FPTequivalent to (DFA-SW); this motivated us to introduce a new class of parameterized problems that we call W [Sync]. We prove that as a main result of Section 5. In particular, MONOID FACTORIZATION, BOUNDED TRANSFORMATION RANK(r), and BOUNDED DFA-INTERSECTION are complete for W [Sync]. In Section 6, we describe problems that are both W[2]-hard and belong to W [Sync]. Conversely, in Section 7, we look into problems that are W[Sync]-hard and belong to some of the classes WNL or W [P] or A [2]. We also list problems (in Section 8) that behave similar to DFA-SW, being W[2]hard and belonging to some of the classes WNL or W [P] or A[2], but where the exact relation to W[Sync] is unclear. In Section 9, we return to variations of MONOID FACTORIZATION that often present a completely different complexity behavior. In all sections, we highlight open problems in the hope that this paper can serve as an incentive for further research. More general questions and further thoughts are collected in the concluding Section 10.
A preliminary version of this paper appeared in Bruchertseifer and Fernau (2020).

A Primer in Parameterized Complexity
In this paper, we will encounter quite a number of notions in parameterized complexity. We will assume some familiarity with basic notions of that theory on side of the reader in the following. In particular, a parameterized reduction is a many-one reduction that consumes FPT-time (in our cases, it mostly uses only polynomial time) and translates a parameter value k to a parameter value of f (k) (of the target problem), for some computable function f . One important property of this (as of all reasonable reduction notions) is transitivity: If there is a parameterized reduction from ( 1 , κ 1 ) to ( 2 , κ 2 ) and from ( 2 , κ 2 ) to ( 3 , κ 3 ), then there is parameterized reduction from ( 1 , κ 1 ) to ( 3 , κ 3 ). Here, κ i denotes the parameterization (function) for clarity. A parameterized complexity class can be characterized by one (complete) problem, assuming the class is closed under parameterized reductions. Examples comprise the following classes; for the typical problems, the parameter will be always called k: Given a nondeterministic single-tape Turing machine and k ∈ N, does it accept the empty word within at most k steps?

W[2]
Given a nondeterministic multi-tape Turing machine and k ∈ N, does it accept the empty word within at most k steps?

A[2]
Given an alternating single-tape Turing machine whose initial state is existential and that is allowed to switch only once into the set of universal states and k ∈ N, does it accept the empty word within at most k steps?
WNL Given a nondeterministic single-tape Turing machine and some integer ≥ 0 in unary and k ∈ N, does it accept the empty word within at most steps, visiting at most k tape cells?

W[P]
Given a nondeterministic single-tape Turing machine and some integer ≥ 0 in unary and k ∈ N, does it accept the empty word within at most steps, thereby making at most k ≤ nondeterministic steps?
More details can be found in textbooks like Downey and Fellows (2013), Flum and Grohe (2006). The Turing way to these complexity classes (i.e., using variants of Turing machines and defining parameterized problems on these machines) is described also in Cesati (2003), Guillemot (2011). However, choosing a "typical" problem and defining a (parameterized) complexity class as the set of all (parameterized) problems that are reducible (with a reasonable notion of reducibility) to clearly also works for problems not related to Turing machines. In this paper, we actually suggest a new parameterized complexity class W[Sync] as the class of parameterized problems that can be (parameterized) reduced to DFA-SW, a class that is situated as drawn in Figure 1,  , para-NP and XP. Let us briefly introduce the complexity classes FPT, 2 XP and para-NP, also see Flum and Grohe (2006): If a parameterized problem can be solved in time O * (f (k)) (for some function f ) by a deterministic algorithm, belongs to FPT. If a parameterized problem can be solved in time n f (k) for instances (x, k) of size n for some function f , then ∈ XP. If there is a nondeterministic algorithm running in time O * (f (k)) (for some function f ), then ∈ para-NP. For definitions of the other classes, we refer to the mentioned textbooks. From the literature, the following relations are known: Each of the inclusions that we have explicitly written is conjectured but not known to be strict. Also, no non-trivial inter-relations are known between the A-and W-hierarchies, apart from Guillemot defined WNL in Guillemot (2011) in the same way as we described it above. Interesting formal language problems complete for WNL include BOUNDED DFA-INTERSECTION, given k DFAs, with parameter k, plus the length of the word that should be accepted by all k automata, or LONGEST COMMON SUBSEQUENCE, parameterized by the number of given strings. We will come back to these problems with different parameterizations below. WNL is situated above all levels of the W-hierarchy, because the last two mentioned problems are known to be hard for W[t] for any t ≥ 1, see Bodlaender et al. (1995), Wareham (2001). This proves the first part of the following theorem that we include also for the ease of reference.
Proof. Clearly, by a standard product automaton construction, BOUNDED DFA-INTERSECTION can be tested in time O(n k ), where n is the maximum number of states of the input DFAs. Hence, WNL is included in XP.
Recall that membership of BOUNDED DFA-INTERSECTION (parameterized by the number of automata) in WNL follows by guessing an input word letter-by-letter, keeping track of the DFAs by writing their k current states, plus a counter for the number of steps, on the tape of the Turing machine M. We can do so by using as many letters as there are states in the automata, plus q (which is given in unary). Alternatively, when counting the number of bits needed to write down the tape contents using the alphabet {0, 1}, this amounts in O(k log(n)) many bits, if n upper bounds the size (number of bits) of (an encoding) of a BOUNDED DFA-INTERSECTION instance. Assuming that M has s many states, then there are obviously no more than s · 2 O(k log n) many configurations of M. With the help of an additional counter, using log(s · 2 O(k log n) ) = log(s) + O(k log n) many additional bits, we can ensure that such a nondeterministic Turing machine M (simulating M) would need no more time than s · 2 O(k log n) when moving through the configuration graph, avoiding visiting configurations twice. This proves the claimed membership in para-NP. Hence, WNL is included in para-NP.
As a final remark concerning this detour to parameterized complexity, observe that WNL is also closely linked to the class N[f poly, f log] of parameterized problems that can be solved nondeterministically (at the same time) obeying some time bound f (k) · n c for some constant c and some space bound f (k) · log(n), where f is some (computable) function, k is the parameter (value), and n gives the instance size, as discussed in Elberfeld et al. (2015). Our reasoning also shows that BOUNDED DFA-INTERSECTION (parameterized by the number of automata) lies in N[f poly, f log]. Hence, WNL can be seen as the closure of N[f poly, f log] under parameterized reductions. So, although one can argue that N[f poly, f log] (and also some other classes introduced by Elberfeld et al. 2015) is a better model of parameterized space complexity, WNL fits better into the landscape of the W-hierarchy also depicted in Figure 1, being closed under parameterized reductions by its definition. Recall that parameterized reductions speak about time bounds and are hence not that well related to space complexities. Therefore, Elberfeld, Stockhusen, and Tantau considered other types of reductions in Elberfeld et al. (2015). Because WNL is a less known class that is still quite central to our current discussion, let us mention a variation of DFA-SW in the following. For a subset of states P ⊆ Q of a DFA A = (Q, , δ, q 0 , F), we say that w ∈ * is P-synchronizing if, for all p ∈ P, δ * (p, w) = s for some s ∈ Q. In other words, a word is synchronizing for A if it is Q-synchronizing.

DFA-SW-FROM-SUBSET-SB (where SB indicates a size bound)
Input: DFA A with state set Q as well as k, m ∈ N and subset P ⊆ Q with |P| = k Problem: Is there a P-synchronizing word w for A with |w| ≤ m?
Notice that if m is given in binary and the restriction |P| = k is missing, then this problem is even PSPACE-complete, because subset synchronization in itself (without the length bound) is already PSPACE-complete; see  and Rystsov (1983) for more discussions. However, if m is presented in unary, as implicit in the problem definition, because the input DFA comes with a list of its states and this list contains more elements than k, then the problem is "only" NP-complete, as it also follows from Montoya and Nolasco (2018), but this also follows when considering P = Q. However, Montoya and Nolasco focused on the parameterized complexity of DFA-SW-FROM-SUBSET-SB and could prove the following result.
Theorem 2. DFA-SW-FROM-SUBSET-SB, parameterized with the set size parameter k, is complete for the class WNL, even when restricted to planar automata graph instances.

Finding a Home for DFA-SW
As mentioned above, DFA-SW is known to be W[2]-hard. However, no complexity class was hitherto suggested to which DFA-SW belongs. In this section, we will describe three different memberships.
Theorem 3. DFA-SW, parameterized with the length parameter k, is contained in the class WNL.
Notice that membership in WNL does not follow with the arguments presented by Montoya and Nolasco (2018) for a different parameterization of the related problem DFA-SUBSET-SBSW, because that argument makes explicit use of the fact that the given set P of states contains k elements.
Proof. We now describe a nondeterministic Turing machine that visits at most f (k) many cells (ever), providing the required reduction. Given a DFA A with state set Q and input alphabet , where, w.l.o.g., Q ∩ = ∅, together with a bound k on the length of a synchronizing word, a Turing machine M is constructed that works as follows: (1) M writes a word of length at most k over the alphabet on its tape, followed by some letter from the alphabet Q; this means that M starts with making (at most) k + 1 nondeterministic guesses.
(2) For each q ∈ Q (this information can be hard-coded in the finite-state memory of M), M first moves its head to the left end of its tape and then starts reading the tape content from left to right. Each time a symbol a ∈ is read, M updates the current state it stores according to the transition function of A. Finally, M will read a symbol from Q, and it will only continue working if this symbol equals the current state stored in the finite memory of M.
Notice that (2) works deterministically. (3) Only if M has completely processed the loop described in (2) (without abort), M will accept.
This verifies that the guessed word over is indeed synchronizing, always leading into the state that was also previously guessed. Hence, M will accept the empty word if and only if there is a possibility to guess a synchronizing word of length at most k. It is also clear that the Turing machine makes at most (|Q| + 1)(2k + 1) many steps. 3 Unfortunately, we do not know if our problem is WNL-hard. Let us also remark that our reasoning in the previous result also proves that DFA-SW, parameterized with the length parameter k, is contained in N[f poly, f log], a class introduced in Elberfeld et al. (2015) and also discussed above. We could also re-interpret the arguments of the previous proof to show that DFA-SW belongs to W[P], based on the Turing machine characterization of W[P].
We failed when trying to put DFA-SW into W [SAT]. In order to understand the difficulties, let us discuss a different strategy how to put DFA-SW into W[P]. Recall the following relationships:

W[SAT]
is characterized (via parameterized reductions) by the following problem. Given an arbitrary Boolean formula ϕ, with X being its set of variables, does there exist an assignment α : X → {0, 1} that satisfies ϕ, such that at most k variables are set to true (i.e., to 1)? Here, k is the parameter, also called the weight of the assignment. Similarly, W[P] is characterized by the following problem. Given a Boolean circuit C, with X being its set of Boolean input variables, does there exist an assignment α : X → {0, 1} of weight at most k that satisfies C? Apart from the fact that circuits (graph-theoretically speaking, directed acyclic graphs) can represent Boolean functions more succinctly than formulas, another difference comes from the (related) fact that circuits can contain implicit variables (associated to inner logical gates) that might have to be made explicit in Boolean formulas, which means in particular that the weight of an assignment can change when moving from a Boolean circuit to an equivalent Boolean formula. This is the reason why we can prove in the following that DFA-SW, parameterized with the length parameter k, is contained in W[P], but we do not know if we can adapt this proof toward showing membership in W[SAT]. As mentioned above, we cannot tell what the relations between WNL and W[SAT] or W[P] are, but assuming that WNL = W[P] holds, the following construction also shows that DFA-SW, parameterized with the length parameter k, is neither WNL-hard nor W[P]-hard. Proof. We only give a sketch of the construction of a Boolean circuit that allows an assignment of weight k that outputs true if and only if the given DFA A = (Q, , δ, q 0 , F) has a synchronizing word of length at most k.
• We introduce an input gate I a,i for each a ∈ and 1 ≤ i ≤ k. The meaning should be the following: Symbol a is at position i in the synchronizing word that is guessed via an assignment to these input gates. Hence, we check with a small auxiliary logical sub-circuit if (exactly) one of the inputs from {I a,i | a ∈ } is set to one. In the following description, let w denote the word of length k that is meant by a satisfying assignment.
• Moreover, there are (internal) gates S q,i,p for q, p ∈ Q and 0 ≤ i ≤ k, meaning that each of these gates outputs true if A, when started to digest the input w within state q, will reach state p after i steps. In particular, we can initialize S q,0,p to output one (true) if and only if q = p. For i > 0, the gate S q,i,p outputs true if and only if both I a,i and S q,i−1,r output true and δ(r, a) = p. • Finally, the output gate O collects the information of all gates S q,k,p ; it outputs true if and only if there is one p ∈ Q such that for all q ∈ Q, S q,k,p outputs true.
It should be clear that the circuit that we described can be constructed in polynomial time if k is given in unary (and in FPT-time otherwise, which is good enough for our purpose).
A reader who knows about the definition of the W-hierarchy in terms of weft will also recognize that this construction does not prove membership within any fixed level of that hierarchy, because the number of so-called large gates on paths from input gates to the output gate grows with k.
We are now going to prove membership in yet another parameterized complexity class, namely A[2]. Besides the mentioned W-hierarchy, there is another hierarchy of hard parameterized problems, which is the A-hierarchy. The best explanation of this hierarchy can be found in the textbook of Flum and Grohe (2006). It is known that , so that the following membership of DFA-SW, parameterized with the length parameter k, can be seen as an indication that our problem is not complete for A [2].
Recall that also A[2] possesses a characterization in terms of Turing machines. Now, we are facing an alternating single-tape Turing machine whose initial state is existential and that is allowed to switch only once into the set of universal states when trying to accept the empty word in at most k steps, where k is the parameter. By observing that the switch between phases (1) and (2) of the description of the Turing machine M in the proof of Theorem 3 can be also viewed as switching between existentially and universally quantified states, M can be also re-interpreted to show:

Theorem 5. DFA-SW, parameterized with the length parameter k, is contained in the class A[2].
The latter result also follows when combining the reductions of Lemmas 14 and 15 below, because parameterized reductions are transitive as a relation between parameterized problems.
Let us now state the position of W[Sync] within the better known parameterized complexity classes more formally.

Further Problems Complete for W[Sync]
In the following problem statements, k is always the parameter that we are analyzing with respect to parameterized complexity. In each case, we prove a completeness result for W[Sync].

DFAs with a sink state
Our first example is an easy modification of our basic problem DFA-SW. Recall that a state s of a DFA is a sink state if for all input letters a, we have δ(s, a) = s. Observe that if a DFA A possesses a sink state s, then A is synchronizable if and only if s is reachable from each (other) state of A; moreover, s is then the unique possible synchronizing state.

DFA-SYNCHRONIZING WORD WITH A SINK (DFA-SW-SINK)
Input: DFA A with a sink state, k ∈ N Problem: Is there a synchronizing word w for A with |w| ≤ k?

Lemma 2.
There is a polynomial time computable parameterized reduction that produces, given some DFA A and some integer k as an instance of DFA-SW, an equivalent instance (A , k ) of DFA-SW such that A possesses a sink state.
Proof. Consider the DFA A = (Q, , δ, q 0 , F). Without loss of generality, assume ∩ Q = ∅ and σ / ∈ ∪ Q. Let = ∪ Q ∪ {σ } be the input alphabet of the DFA A that we are going to construct. An example for this construction can be found below.
Define the transition function δ as described in Figure 2. This describes the interesting aspects of the automaton A . We claim that, letting k = k + 1, then A has a synchronizing word of length at most k if and only if A has a synchronizing word of length (at most and exactly) k .
Let w ∈ * be a synchronizing word, leading A into state q f ∈ Q, with |w| ≤ k. Then, it is easy to observe that the word w = σ k−|w| wq f leads A into the sink state f , wherever A starts. Hence, w is a synchronizing word of length k as claimed. Notice that due to the sequence of states s 0 , . . . , s k , f , there cannot be any shorter synchronizing word in A .
Conversely, let w be a synchronizing word of length at most k for A . As f is a sink state, it must be the synchronizing state. Since in particular δ * (s 0 , w ) = f , |w | = k = k + 1, and for the same reason, w = w q for some w ∈ ( ∪ {σ }) k and q ∈ Q. Observe that the special letter σ either loops (on Q ∪ {f }) or advances as any other letter from (on Q \ Q). Therefore, if w is synchronizing for A , then so is σ k−|w| wq, where w is obtained from w by deleting all occurrences of σ , that is, w ∈ * . As σ acts as the identity on Q, and because the final letter q indicates that, upon starting in some state from Q, the automaton must have reached state q (as w is leading to the sink state f ), we can see that w is indeed a synchronizing word for A; moreover, |w| ≤ k. This proves the correctness of the transformation. We will give an example for this proof in the following. As an example automaton, we chose the famous 4-state DFA designed byČerný (drawn in Figure 3) to illustrate that shortest synchronizing words could be surprisingly long, in this case, of length nine. More precisely, w = baaabaaab leads all four states to q 1 , so that wq 1 synchronizes the resulting automaton (in our construction) if k ≤ 9. The resulting automaton can be found in Figure 4.

Remark 1.
Let us mention one more formal language fact about synchronizing words: there is a synchronizing word of length exactly k for a DFA A if and only if there is a synchronizing word of length at most k for A. This comes from the fact that if w is a synchronizing word, then also wu is synchronizing for any word u. Therefore, we can also employ the problem variation asking about the existence of a synchronizing word of length exactly k if it is more convenient.

Synchronizing subsets
As mentioned above, the question if a given subset of states can be synchronized poses even a PSPACE-complete problem. When enriched with a length bound on the length of a subsetsynchronizing word, we are back to an NP-complete problem, assuming that the length bound is given in a unary encoding. Motivated by these considerations, we consider the following parameterized problem.
Is there a P-synchronizing word w for A with |w| ≤ k?
Recall that we previously discussed this problem with the parameter |P|, calling it DFA-SW-FROM-SUBSET-SB for clarity. Notice that our discussions from Remark 1 translate verbatim also to this problem variation.
Proof. As a Q-synchronizing word is just another name for a synchronizing word, it is Consider a DFA A = (Q, , δ, q 0 , F), together with a state subset P and an integer k. We define a new DFA A = (Q , , δ , q 0 , F) and an integer k = k + 1 such that A possesses a P-synchronizing word of length k if and only if A has a synchronizing word of length k . LetP = {p | p ∈ P} consists of (barred) copies of the states in P and let Q = Q ∪P. Let c / ∈ be a fresh letter. Let = ∪ {c}. The transition function δ equals δ when restricted to Q × . Now, fix some p fix ∈ P. Furthermore, define δ (q, c) = p fix for q ∈ Q \ P and δ (p, c) = δ (p, c) = p as well as δ (p, a) =p for any p ∈ P and a ∈ . Now, if w is a P-synchronizing word for A, then (by construction) cw is a synchronizing word for A . Conversely, if v is a synchronizing word for A , then it must contain at least one occurrence of c, because otherwise there is no way to synchronize the states fromP, as by construction, the states inP cannot be synchronizing states. Assuming that v is of minimum length, we can deduce that v contains exactly one occurrence of c and this occurrence is at the very beginning of c. Now, after reading c and starting out from Q , the DFA A will be in any of the states of P, which means that if we write v = cw, then w is a P-synchronizing word for A.

Factoring monoids
We now present a problem originally introduced by Cai et al. (1997) in the context of parameterized complexity. As also discussed in Section 9, it is crucial that the monoid in question is implicitly given in this type of generator problem.
MONOID FACTORIZATION (see Cai et al. 1997) We can speak of k as (an upper bound on) the generation length of f 0 . This problem (without the generation length bound k) was introduced as GEN in the seminal work of Kozen (1977) and proven to be PSPACE-complete; it appeared as MS5 under the quite fitting name FINITE FUNCTION GENERATION in Garey and Johnson (1979, p. 280). With the generation length bound, MONOID FACTORIZATION, restricted to collections of bijections (i.e., permutations), was proven to be NP-complete in Even and Goldreich (1981); this restricted problem was termed MINIMUM GENERATOR SEQUENCE by Even and Goldreich. We will discuss further variations of MONOID FACTORIZATION concerning aspects of parameterized complexity in Section 9.
With some background knowledge on transition monoids, it is clear that by interpreting a given DFA A = (Q, , δ, q 0 , F) as a collection F A of | | many mappings f a : Q → Q, by setting f a (q) = δ(q, a), we can solve a DFA synchronization problem given by (A, k) by solving |Q| many This shows that DFA-SW, parameterized with the length upper bound k, can be solved by a Turing reduction to MONOID FACTORIZATION, parameterized with the generation length upper bound k. Below, we will strengthen this toward presenting a many-one reduction.
Having a closer look at the proof of W[2]-hardness of DFA-SW, parameterized with the length upper bound k (also discussed below in more details), which was presented in Fernau et al. (2015), we see that the resulting automaton has one sink state, and hence, this is the only possible synchronizing state. This means that the Turing reduction suggested in the previous paragraph can be indeed viewed as a many-one (Karp) reduction, as the constant target function is uniquely defined. Hence, this reasoning shows that MONOID FACTORIZATION, parameterized with the generation length upper bound k, is indeed W[2]-hard. This result has been shown already in Cai et al. (1997) by a different reduction from DOMINATING SET.

Lemma 3.
There is a polynomial time computable parameterized many-one reduction from MONOID FACTORIZATION, parameterized with some generation length upper bound, to DFA-SW, parameterized with some length upper bound.
. . , a m , σ , τ } and define the transition function δ : Q × →Q as defined in Figure 5. This describes the interesting aspects of the automaton A F . An illustrative example will be discussed below. We claim that ( When started in some (q 1 , q 2 ), A F will be in state (q 1 , q 1 ) after digesting σ k−k +1 . The word a i 1 · a i 2 · · · a i k will then drive A F into some state (q 1 , q 2 ). Now, upon reading τ , A F could only enter (the only) synchronizing state f if q 2 = f 0 (q 1 ) was true. If A F starts reading w in any of the states {s 0 , . . . , s k , s k+1 , f }, it is straightforward to check that A F will be in state f thereafter.
Conversely, if w is any word of length at most k + 2 that is synchronizing for A F , then it must be of length exactly k + 2, as this is the shortest path length from s 0 down to f , which is a sink state and must hence be the synchronizing state. This also enforces w to start with σ and to end with τ . Also, w cannot contain another occurrence of τ , as this would lead to s 0 again (from any of the states s i ) and thereby prevent w from entering f , because the states s i should be walked through one-by-one, hence counting up to k + 2. Let us study the longest suffix vτ of w that satisfies v ∈ {a 1 , . . . , a m } * . By the structure of w that we analyzed before, we must have w = uσ vτ , for some possibly empty word u such that uσ starts with σ . In particular, |v| ≤ k, as |u| + |v| = k. Hence, after reading the symbol σ preceding v, A F will be in one of the states (q, q) or s i (for some |u| + 1 ≤ i ≤ k + 1) or f . Now, digesting v leads us into one of the states s k+1 or f or (q, p), Let us give an illustrative example for the construction used above in Lemma 3. We are considering the following three mappings f i : Q → Q, with Q = {1, 2, 3, 4}. This describes, together with some integer k ≥ 0, our instance of MONOID FACTORIZATION. In the equivalent instance of DFA-SW, the mappings f 1 and f 2 are modeled as the action of letters, leading to a two-letter input alphabet, say, = {a, b}, which is enriched by two more symbols, σ , τ . In particular, σ and τ together model the target mapping f 0 (which is constant in our case), so that this construction, which can be found in Figure 6, results in another DFA capable of simulating the mentioned 4-state DFA designed byČerný (depicted in Figure 3) by an automaton with a sink state, yielding a somewhat more complicated construction (to this end) than the aforementioned one from Lemma 2 (see Figure 4). Proof. As each DFA-SW-SINK is trivially an instance of DFA-SW, the previous lemma shows the result.
We like to mention that there is another algebraic problem studied in the literature that looks quite similar to MONOID FACTORIZATION and that we define next: Figure 6. An example for our construction from Lemma 3. Notice the similarities of the mappings to the actions of letters iň Cerný automaton (Figure 3). For arcs without labeling, the following holds: Arcs carried out with a or b, respectively, in thě Cerný automaton (i.e., the mappings f 1 and f 2 , respectively) are solid or dashed, respectively. Arcs resulting from transitions with σ or τ , respectively, are dotted, or dotted and dashed, respectively. Note that the arcs labeled τ are omitted in all vertices (i, j) for the sake of readability. They would lead from (i, i) to f and from (i, j) to (i, 1) when j = i. BOUNDED TRANSFORMATION RANK(1) (see Goralčík and Koubek 1995) Input: A finite set Q, a collection F = {f 1 , . . . , f m } of mappings f i : Q → Q, k ∈ N Problem: Is there a selection of at most k mappings f i 1 , . . . , f i k , k ≤ k, with i j ∈ {1, . . . , m} for j = 1, . . . , k , such that f 0 := f i 1 • f i 2 • · · · • f i k satisfies |f 0 (Q)| = 1 (i.e., rank equals 1)?
With the idea of transformation monoids in mind, it is rather straightforward to see that this problem can be viewed just as an algebraic reformulation of DFA-SW; this was also observed in Volkov (2008). We therefore only state the consequence that is interesting for our context.  Goralčík and Koubek (1995) also considered the problem BOUNDED TRANSFORMATION RANK(r) for any r ≥ 1. 4 This means that the condition |f 0 (Q)| = 1 is replaced by |f 0 (Q)| = r in the problem definition above. By adding further elements to Q on which the mappings all act as identities, one easily obtains the next result.
Corollary 5. For any r ≥ 1, BOUNDED TRANSFORMATION RANK(r), parameterized by an upper bound k on the generation length, is hard for W [Sync].
As r is part of the problem definition (and hence fixed), we can strengthen the previous two statements as follows: We are now defining a collectionF of mappings fromQ toQ that contains F in this sense. We add r · O(|Q| r ) many mappings g A,j :Q →Q intoF. Here, A ⊆ Q, |A| = r, j ∈ [r] = {1, . . . , r}. More precisely, In all other cases, g A,j (x) = x. Furthermore, we add k − 1 increment mappings ι j with ι j (j) = j + 1 if j ∈ [k − 1] that act as the identity on all other elements ofQ. Finally, letk = k + r to complete our description of (Q,F,k) constructed from (Q, F, k). Observe that the transformation is polynomial, because r is a constant. In particular, Composing first ι 1 • · · · • ι k δ with f 0 and then with g A,1 , . . . , g A,r gives a mappingf 0 withf 0 (Q) = {s}. As described,f 0 can be expressed by composing k + r =k many mappings fromF.
If h 1 , . . . , h k , k ≤k, exist with h j ∈F for j = 1, . . . , k , such that h 0 := h 1 • h 2 • · · · • h k satisfies |h 0 (Q)| = 1, then by the structure of the mappings inF, h 0 (Q) = {s}. Moreover, as executing mappings from F after executing some g A,j has no further effects but possibly deferring the overall procedure, we can assume that this is not case here. Assuming that the mapping composition yields h 0 , it is clear that the last mapping executed equals some g A,r . As in particular h 0 (1) = s, at least k other mappings must be from F or some increment mappings ι j . As h 0 (c 1 ) = s, we must have used one mapping from {g A,j | A ⊆ Q} for each j ∈ [r]. Due to the length boundk = k + r that is exactly met due to counting through 1, . . . , k and through c 1 , . . . , c r , it is clear that the maps from {g A,j | A ⊆ Q} were selected in order, starting with g A 1 ,1 , through g A r ,r . Moreover, as "wrong selections" are sent to 1 (which is unaffordable by the length boundk), A 1 \ {q 1 } ⊆ A 2 , with q 1 being the first element of A 1 , A 2 \ {q 2 } ⊆ A 3 , with q 2 being the second element of A 2 , etc. means that finally a set A = {q 1 , q 2 , . . . } is selected with |A| = r, a set with which we could have started alternatively. Therefore, we can assume A = A 1 = A 2 = · · · = A r . Hence, we can assume that h 0 is composed as h 0 = f • g, where f = h 1 • · · · • h k , such that h 1 , . . . , h k δ are increments, h k δ +1 , . . . , h k ∈ F and g = h k+1 • · · · • h k+r with h k+j = g A,j for some A ⊆ Q. Now, leaving out all mappings g A,j and all possibly contained increment mappings, we are left with a sequence of k ≤ k many mappings from F that can be re-interpreted as acting on Q. As their composition f 0 , applied to Q, equals A, with |A| = r, the reverse implication is shown.
Finally, notice that due to the tight connections to automata theory, the previous proof can be also interpreted as a W[Sync]-completeness result for the following family of problems RANK(r) DFA-SYNCHRONIZING WORD (with r ≥ 1): Given a DFA A = (Q, , δ) and a number k, does there exist a word w ∈ ≤k such that |δ(Q, w)| = r? This is also true for the problem variation where we ask whether |δ(Q, w)| ≤ r instead. Looking back at the previous proof, this would mean that it is not that important to really count through all elements of up to r to ensure the exact cardinality of the chosen set; smaller sets would suffice.

Input:
A set A of deterministic finite automata with the same input alphabet , k ∈ N Problem: Is there a w ∈ * of length k accepted by all automata in A ?
Here, we took over the definition from Wareham (2001), but as we can also see from the discussion in Remark 1, in our case it is not that important if we ask for a word exactly or at most k. Proof. By Lemma 2, we need to consider only an instance A = (Q, , δ, q 0 , F) of DFA-SW with a sink state s f . Observe that A has a synchronizing word of length at most k if and only if A has a synchronizing word of length exactly k, because wu is a synchronizing word if w is. Define A q = (Q, , δ, q, {s f }) and consider the DFA collection A = {A q | q ∈ Q}. Observe that q∈Q L(A q ) contains some word w ∈ k if and only if A has a synchronizing word of length exactly k. 5 Conversely, if A = {A i | 1 ≤ i ≤ } is a collection of DFAs A i = (Q i , , δ i , q 0,i , F i ), then construct an equivalent instance of DFA-SW as follows. First, assume that the state sets Q i are pairwise disjoint. Then, take two new letters a, b to form = ∪ {σ , τ }. Let Q = i=1 Q i ∪ {s 0 , . . . , s k , s k+1 , f } be the state set of the DFA A that we construct. Define the transition function δ as in Figure 7.
This describes the interesting aspects of the automaton A. We claim that, letting k = k + 2, then i=1 L(A i ) contains some word w ∈ k if and only if A has a synchronizing word of length (at most and exactly) k , namely w = σ wτ . More precisely, similar to the construction from Lemma 3, the states s i force to consider a word from {σ } k {τ } if there should be a synchronizing word of length k for A at all. One could move only from the part A i of A to f when reading τ , which also forces to have been in the set of final states F i before. Digesting σ as the first letter lets A i start in the initial state q 0,i .
We could also discuss the variant when we ask for a word of length at most k to be accepted by all automata in A . However, from the discussions of Remark 1, it immediately follows that also this variant is complete for W[Sync]. Other variations show up when we switch to nondeterministic finite automata or to regular expressions for representing regular languages in these intersection problems. In these cases (and without defining the problems formally), we can only state the following observations. Conversely, it would be interesting to discuss subregular language families for this type of problem, with the question in mind if we (still) obtain W[Sync]-complete problems or not. Notice that (for instance) in the W[2]-hardness proof of Wareham (2001, Lemma 6) concerning BOUNDED DFA-INTERSECTION, only very simplistic automata have been used. This also means that the corresponding regular languages can be easily expressed by simple regular expressions, leading to the following result. . It might be also an idea to quantify the degree of nondeterminism in these studies; we refer to Goldstine et al. (1992). In a sense, the preceding discussions are continued in the next sections, where we discuss other problems between W[2] and W [Sync] or hard for W [Sync], where again the precise parameterized complexity status in unknown.

Problems between W[2] and W[Sync]
One natural way to get problems below W[Sync] is to consider only restricted variants of automata as admissible instances of DFA-SW. For instance, above we considered DFA-SW-SINK. However, it is not always clear that we arrive at problem variants that are complete for W [Sync]. For instance, Bruchertseifer and Fernau (2021) showed that the further restriction to so-called TTSPL automata (where the automaton multi-graphs can be described as two-terminal series-parallel multi-graphs with loops) results in a variation of DFA-SW that is still W[2]-hard, which we were able to concretize in the long version to the effect that it is "only" contained in W [Sync]. In actual fact, it is an open problem if this problem variant is contained in W[2] or W[Sync]-hard, or really something "in-between." As shown by Möhring (1989), there are quite close connections between TTSP(L) graphs and so-called series-parallel partial orders. Without going into any details here, observe that the mappings Q → Q that can be associated to input letters are monotone with respect to the series-parallel partial order corresponding to the TTSPL automaton graph. Our earlier constructions show: Corollary 8. DFA-SW, restricted to DFAs with TTSPL automata graphs, is polynomial time equivalent to MONOID FACTORIZATION, restricted to collections of mappings F that are monotone with respect to a given series-parallel partial order on the finite ground set Q.
This might indicate that we have found yet another class of parameterized problems living inside the by now classical parameterized complexity classes. However, this is just another open problem. As surveyed in Martyugin (2009), there are quite a number of subregular families of DFAs whose length-bounded synchronization problem stays NP-complete. A concise study of the corresponding parameterized complexities is still lacking. These are good further candidates of problems that are possibly complete for W[Sync], yielding lots of open problems.
But, there are further problems lying between W[2] and W[Sync], as we will see next.

Satisfying constraint satisfaction formulae
We consider constraint satisfaction formulae in conjunctive normal form, or CSP CNF for short, in the following. A CSP CNF formula ϕ on k variables x 1 , . . . , x k is given by a finite universe A, atomic sentences x i = a for 1 ≤ i ≤ k and a ∈ A and a CNF built from these atomic sentences. Hence, for A = {0, 1}, this is equivalent to a classical Boolean CNF formula.

Input:
A CSP CNF formula ϕ on k variables x 1 , . . . , x k given by a finite universe A, atomic sentences x i = a for 1 ≤ i ≤ k as well as a ∈ A and a CNF built from these atomic sentences Problem: Is ϕ satisfiable?
The Rystsov-Eppstein proof for NP-hardness of DFA SYNCHRONIZATION given by Rystsov (1980) and Eppstein (1990) can be generalized to cope with CSP CNF formulae, preserving the parameter. This observation already proves: What about the converse? We do not know, but we can prove instead the following hardness result.

Lemma 10. CSP CNF SATISFIABILITY is W [2]-hard.
Proof. We reduce from HITTING SET, a standard W[2]-complete problem. Let U be a universe and let S be a set system over U. Moreover, k is the parameter. The task is to choose k elements u 1 , . . . , u k ∈ U such that for each S ∈ S , u i ∈ S for some 1 ≤ i ≤ k. To express this task as a CSP CNF formula with variables x 1 , . . . , x k , we simply add the clauses k i=1 s∈S x i = s for each S ∈ S . Now, it should be clear that we can choose at most k different elements u 1 , . . . , u k ∈ U to cover all sets in the set system S if and only if the resulting CSP CNF formula (over the universe U) is satisfiable.

Long subsequences
We now discuss the well-known LONGEST COMMON SUBSEQUENCE problem.

Input:
A set of strings x 1 , . . . , x over an alphabet Problem: Is there a string w ∈ k occurring in each of the x i as a subsequence?
As explained in Wareham (2001), by building an automaton A i for each x i that accepts all subsequences of x i , it is not hard to solve a LONGEST COMMON SUBSEQUENCE instance by a BOUNDED DFA-INTERSECTION instance, preserving our parameter. Hence: Observe that we can also use the previous proposition to prove Lemma 9, because one can modify the proof of Theorem 3 in Bodlaender et al. (1995) to show the reduction CSP CNF SATISFIABILITY ≤ FPT LONGEST COMMON SUBSEQUENCE. Unfortunately, we do not know if LONGEST COMMON SUBSEQUENCE is also hard for W [Sync]. We only know W[2]hardness from Bodlaender et al. (1995); further membership results were unknown hitherto, so the previous proposition remedies this situation a bit.

Discussions
One could also think of many ways to restrict the inputs of BOUNDED DFA-INTERSECTION. For instance, observe that the automata constructed in the argument of Proposition 11 are all accepting finite languages. Is there a converse reduction from such a BOUNDED DFA-INTERSECTION instance to some LONGEST COMMON SUBSEQUENCE instance? Might this open question lead to another interesting complexity class between W[2] and W[Sync]?
Let us also mention that Guillemot (2011) has shown that LONGEST COMMON SUBSEQUENCE, parameterized by the number of strings , is complete for WNL. Likewise, BOUNDED DFA-INTERSECTION, parameterized by the number of automata, is complete for WNL. Hence, whether or not two problems are FPT-equivalent clearly depends on the chosen parameterization.
Of course, having found two concrete problems between W

Problems Hard for W[Sync]
In the following problem statements, k is always the parameter that we are analyzing with respect to parameterized complexity. In each case, we prove a hardness result for W [Sync]. We remind the reader about the unknown status of BOUNDED NFA-INTERSECTION. We also discuss memberships in WNL, A[2], A[3], and W[P].

Intersecting regular languages again
Lemma 12. BOUNDED NFA-INTERSECTION, parameterized by the length of the commonly accepted string, is contained in WNL.
Proof. We only sketch this proof, as it parallels previous ones. Let A be a collection of NFAs and k ∈ N. We can design a nondeterministic one-tape Turing machine M (starting on the empty input) that first guesses a string w of length k and then verifies, for each automaton A ∈ A , that A accepts w. Only if all these simulations succeed, M will accept. As required, M needs only space k.

Extensions and orderings of words
Extension variants of SYNCHRONIZING WORD have been studied before, as in . The underlying problem, which depends on the choice of a partial order ≺ on the set of all words, is defined as follows: EXT DFA-SW-≺ Input: DFA A with input alphabet , u ∈ * Problem: Is there a w ∈ * , u ≺ w, such that w is minimal for the set of synchronizing words for A with respect to ≺ ?
Please note that the complexity varies fundamentally with the choice of the partial order. In the following, we will concentrate on the length-lexicographical ordering ≤ ll as the partial order, where v ≤ ll w means that either |v| < |w| or that |v| = |w| and v ≤ lex w, where v ≤ lex w refers to a lexicographical (total) order induced by a given total order on the alphabet. In  and in Bruchertseifer and Fernau (2021), we are also discussing other (natural) partial orders. It should be noted that in some cases, the extension variants are solvable in polynomial time, while other cases lead to NP-or co-NP-hard problems. In particular, there is a co-NP-hardness of EXT DFA-SW-≤ ll . To avoid clumsy formulations, we will therefore consider the NP-hard problem CO EXT DFA-SW-≤ ll instead that reverses YES with NO answers compared to EXT DFA-SW-≤ ll .
Proof. For membership CO EXT DFA-SW − ≤ ll ∈ WNL ∩ W[P] ∩ A[2], we can modify the according proofs of Theorems 3, 4, or 5, constructing a nondeterministic Turing machine M as follows, given A and u. As in the previous construction, the machine can first guess a possible word w ≤ ll u and verify if it is synchronizing. If such a word is found, then (A, u) is a NO-instance. The reduction itself checks if A is synchronizable at all, which can be done in polynomial time according to Sandberg (2005) and Volkov (2008). We also have that if M does not find a synchronizing word w ≤ ll u, then (A, u) is a YES-instance, because as A is synchronizable, there must be a synchronizing word v. Remind that according to the previous tests, u ≤ ll v must hold.
We are now turning to the second claim. Consider a DFA A on the input alphabet , together with a number k, as an instance of DFA-SW. We can first check in polynomial time if A is synchronizable at all. If A is not synchronizable, then (A, k) (clearly) is a NO-instance of DFA-SW, so our reduction will produce some fixed NO-instance of CO EXT DFA-SW-≤ ll . Hence, we now assume that A is synchronizable. Let c / ∈ be a fresh letter. Consider an arbitrary ordering < on , extended by c < x for all x ∈ toward an ordering onˆ = ∪ {c}. We are going to define the DFAÂ as an extension of A, working on the same state set Q. Let c simply act as the identity on Q. Hence, no word from c * is synchronizing forÂ. As A is synchronizable,Â is also synchronizable. ConsiderÂ together with u = c k+1 as an instance of CO EXT DFA-SW-≤ ll . IfÂ has a synchronizing word w of length at most k, then clearly u is not extendible, as |w| < |u|. Otherwise, asÂ is synchronizable,Â must have some synchronizing word w with |w| ≥ |u|, and any synchronizing word ofÂ is of length at least |u|. As u is the smallest of all words inˆ * of length at least |u|, any synchronizing word will hence extend u. Hence, ifÂ has no synchronizing word of length at most k, then u is extendible.
The natural open question is if CO EXT DFA-SW-≤ ll is in W [Sync].
In Bruchertseifer and Fernau (2021), we also showed that EXT DFA-SW-≤ | is W[3]-hard, where | refers to the (scattered) subsequence ordering. But it is an open question if this extension problem belongs to W [3]. Notice that there are few natural parameterized problems higher up in the W-hierarchy; see Chen and Zhang (2006). However, the very idea of extension problems (not only applicable to formal language problems) seems to lead to such problems; we also refer to Bläsius et al. (2019), Casel et al. (2018.

Input:
A nondeterministic finite automaton A = (Q, , δ, Q 0 , F), k ∈ N Problem: Is there a word w ∈ k that is not accepted by A?
Proof. We reduce from BOUNDED DFA-INTERSECTION. Let A be a set of deterministic finite automata with the same input alphabet . To be more precise, let A = {A 1 , . . . , A n } with Interpreting the function δ i as a set of triples (q i , a, p i ), with q i , p i ∈ Q i and a ∈ , we can define the relation δ as δ = n i=1 δ i . Now, w ∈ * is accepted by all DFAs A i if and only if w is not accepted by A, because the state sets Q i are pairwise disjoint.
Observe that the NFA A constructed in the preceding proof is very special, as its transition relation is actually a mapping. The only source of nondeterminism comes from the fact that A has n initial states. Alternatively, we could create a new single initial state q 0 and add transitions (q 0 , a, p i ) whenever there is a transition (q i,0 , q, p i ) ∈ δ i . This way, we can get an NFA A with the property that for any w ∈ + , w is accepted by all A i if and only if w is not accepted by A . Notice that now there is only one state (namely q 0 ) that can be seen as the source of nondeterminism of A . In particular, this proves that the number of "nondeterministic states" is not a useful (additional) parameter. Moreover, if an NFA with a single initial state and no "nondeterministic state, " that is, a DFA, is given, the question of the existence of a word of length k that is not accepted by this automaton becomes easy (solvable in polynomial time) by a product automaton construction, reducing it to the question of testing a single DFA for non-emptiness.

Lemma 15. BOUNDED NFA NON-UNIVERSALITY belongs to A[2].
Proof. We describe the work of an alternating single-tape Turing machine M that can be produced from a given NFA A = (Q, , δ, Q 0 , F) and k ∈ N in polynomial time, such that M accepts the empty word in 2k steps if and only if there is a word w ∈ k that is not accepted by A. In the following, we describe how M works, and this way we also give sufficient details on how to construct M. The state set of M consists of P = {p 0 , . . . , p k } and Q (the state set of the given NFA), where P \ {p k } are existential states and Q ∪ {p k } are universal states. The state p 0 is the initial state of M. The set of final states of M is Q \ F.
• First, M writes k letters from on its tape, moving its head from left to right. In this phase, M traverses the states p 0 , . . . , p k in order. It ignores the tape contents (which should be empty anyways in the beginning). • After entering p k , M reads the tape contents backwards, until it reaches the left end of the tape (again). More precisely, when being in state p k , M ignores its tape contents, and stays where it is, but moves from state p k (universally) to any of the states of Q 0 . • When being in a state q from Q, M does the following: -It reads a tape symbol a.
-The tape head moves one step to the left. • When M detects the right border of the tape, it stops working and accepts if it is in a state from Q \ F.
As the states of Q ∪ {p k } are universal, all possible computation paths of A are checked if they do not accept the guessed word w ∈ k . Therefore, the described reduction works.
Notice that there are several aspects of the reduction described in the previous proof that might need small adaptations if we use a different concrete model of an alternating Turing machine. For instance, we (implicitly) assumed a Turing machine model where the tape is only (potentially) infinite to the right, but bounded to the left, and the left border could be detected. If we assume a tape that is (potentially) infinite to both sides, then we might need two more steps (of the Turing machine) to implement a left border by first printing a special border symbol and reading it in the end. But these details are inessential for our complexity result.
It is unclear to us (and hence an open question) if BOUNDED NFA NON-UNIVERSALITY belongs to WNL or to W[P], because in both cases, we face a model of nondeterministic Turing machine (if we follow the Turing way paved by Cesati 2003) that cannot cope with checking all possible nondeterministic ramifications of the given NFA, in particular, because the step bounds are given in unary. This leads to the intuition that BOUNDED NFA NON-UNIVERSALITY is indeed "harder" than DFA-SW. However, we do not see either why BOUNDED NFA NON-UNIVERSALITY should be hard for WNL or for W [P]. For instance, in order to prove WNL-hardness, one could start with a BOUNDED DFA-INTERSECTION instance (A , k), now parameterized by |A |. However, in any classical construction linking BOUNDED DFA-INTERSECTION to BOUNDED NFA NON-UNIVERSALITY, there is no obvious connection between |A | and the string length parameter of BOUNDED NFA NON-UNIVERSALITY.

Problems that Feel Similar to Synchronizing DFAs
In this section, we like to collect problems that are W[2]-hard and belong at least to some of the classes A[2], W [P], or WNL, but where the relation to W[Sync] is unknown. Alas, we can present only one concrete problem, again related to synchronization. Türker and Yenigün (2015) asked to extract a synchronizable sub-automaton that is as small as possible, obtained by deleting letters from its specification. This notion of a sub-automaton is of particular interest to us, as we are dealing with completely specified deterministic automata, and DFAs are not closed under most other notions of sub-automaton one might come up with, because they tend to produce incomplete automata. Türker and Yenegün formalized this idea as a weighted minimization problem. For our purposes, it is sufficient to consider the following unweighted variant: DFA-MSS (referring to a minimum synchronizable sub-automaton)

Input:
DFA A with input alphabet , k ∈ N Problem: Is there a sub-alphabetˆ ⊆ , |ˆ | ≤ k, such that the restriction of A toˆ is synchonizable?
Interestingly, Türker and Yenegün used nearly the same reduction as Fernau, Heggernes, and Villanger in Fernau et al. (2015) for a different purpose to prove the following result.
From that reduction, we can observe the following. Proof. Let (A, k) be an instance of DFA-MSS. Notice that in a first preprocessing step, we can eliminate letters a that act the same on the state set Q as another letter a that we decide to keep. Such a rule can be implemented to run in polynomial time, as we simply loop over all pairs of letters, so that we can now assume to face an automaton A with input alphabet and state set Q such that | | ≤ |Q| |Q| . Moreover, we can assume that contains more than log(|Q|) many symbols, as otherwise we can test all subsets of (for synchronizability) in polynomial time. Finally, we can test in polynomial time if A itself is synchronizable at all, as proven in Sandberg (2005) and Volkov (2008). Recall that the algorithm checking synchronizability tests if any pair of states can be synchronized within at most |Q| steps. We adapt this strategy in the following. Now, we hard-wire the DFA into a Turing machine M as described in the following. In particular, this means that this Turing machine can keep track of pairs of states, say, (q, p) and update this information toward (q , p ) in its finite memory (alternatively, on the tape, using state letters) upon reading a symbol a ∈ , such that q is reached from q (in the given DFA) and p is reached from p upon reading a. We also assume a fixed linear ordering < on the state set Q, and moreover, we assume that Q ∩ = ∅. Let q a and q b be the smallest and second-to-smallest states in Q.
The Turing machine M first guesses a sub-alphabet by writing the corresponding k input letters on its tape. Moreover, it writes down q a next to q b . After reading (and memorizing) the current state pair (q, p), initially (q, p) = (q a , q b ), the machine (nondeterministically) reads one of the k guessed input letters on its tape and transfers to (q , p ) in its internal memory. It continues doing so until it reaches a pair (r, r) for some r ∈ Q. If it reaches such a pair, it is verified that the pair (q, p) written on the tape can be synchronized. It continues by incrementing p on the tape (according to the linear order <) and then testing the synchronizability of the new pair of states on the tape with respect to the guessed sub-alphabet. M loops until the largest element of Q (with respect to <) is reached. Then, it would increment the first component q of the pair and set the second component of the pair of states to the smallest state larger than the first component's state; then, again the inner loop is entered. Finally, when reaching the largest state in the first component, the procedure terminates, this way verifying that the automaton is indeed synchronizable when restricted to the guessed alphabet.
Obviously, the machine M uses only k + c space for some constant c, depending upon details of the implementation. This proves that DFA-MSS belongs to WNL.
Toward proving membership in W[P], recall that two states (q, q ) are synchronizable if and only if there is a path in the following directed auxiliary graph from (q, q ) to the target vertex t: V = Q × Q ∪ {t} is the set of vertices. There is an arc from (q, q ) to (p, p ) if there is some letter a such that the given DFA makes transitions from q to p and from q to p upon reading the letter a. Moreover, there are arcs from any vertex (q, q) to t. In our case, after having guessed the sub-alphabet, this information can be used to construct a sub-graph of the graph just described and write its description down on the tape (in polynomial time). Now, we can use, for example, Dijkstra's algorithm to decide if there is such a path in this sub-graph, deterministically looping through all pairs of states. This describes a Turing machine M that first makes k guesses and then works deterministically a polynomial number of steps and hence proves membership in W[P].
The reader might have expected in the previous proof that logarithmic space would be needed by a Turing machine that (basically) verifies reachability in a graph with |Q| 2 many vertices. Notice that this is implicit in the model, because the Turing machine writes down letters of an arbitrary alphabet on its tape, not just bits. Breaking down to the bit level, one observes that indeed 2 log 2 ( |Q| ) + k log 2 ( | | ) many bits are necessary to write down the letters used by the Turing machine in the previous construction.
Although we found similar parameterized complexity results for DFA-MSS as for DFA-SW, we are not aware of further close links between both problems. In particular, it remains an open question how to solve one problem with the help of the other (respecting our choice of parameters). In particular, the first Turing machine constructed in the previous proof (or straightforward re-interpretations) does not show membership in W[P], because the number of nondeterministic (guess) steps is not bounded in k (so that we had to design a second Turing machine that worked in a different way), nor in A[2], since after guessing k letters, it would enter a universal state (to ensure that all pairs of states are tested for synchronizability), but then the synchronizing word should be guessed again, that is, now this machine would enter again some existential states. Even then, the number of steps is not bounded by a function in k, so that this does not prove membership in A[3]. 6 Furthering this question, we do not know of any fixed level of the A-hierarchy to which this problem belongs.

Further Comments and Discussions on MONOID FACTORIZATION
Observe that it is important that the monoid used in MONOID FACTORIZATION is only implicitly given, not by a multiplication table. A variation could be:

Input:
A finite set M, a binary operation • given in the form of a multiplication table, such that (M, •) forms a finite monoid, with neutral element e ∈ M, a target element t ∈ M, a finite subset B ⊆ M, k ∈ N Problem: Is there a selection of at most k elements b 1 , . . . , b k , k ≤ k, from B, such that t = b 1 • b 2 • · · · • b k ?
However, an explicit representation of the multiplication table of (Q Q , •) (where Q Q is the set of all mappings from Q to Q) would already take O * (|Q| 2|Q| ) space and hence allow to construct an arc-labeled directed graph with a vertex for each mapping Q → Q and an arc-labeled f i from f to g if f • f i = g, where f i is from the explicit set of generators F = {f 1 , . . . , f m }. Now, the representability of f 0 with at most k mappings from F can be solved by looking for a path of length at most k in the directed graph we just described, leading from the identity mapping Q to f 0 . Hence, when the monoid is given in an explicit form, then the factorization problem can be solved in polynomial time (even in NL, see the discussion in Barrington et al. 2001). It might be interesting to study other implicitly given monoids with respect to the factorization question. Let us mention one more example. Assume that our implicitly given monoid operation is set union. Then, the corresponding factorization problem would take subsets {X 0 , X 1 , . . . , X m } of a given finite set S as an input, and the question is to pick at most k sets from {X 1 , . . . , X m }, say, X i 1 , . . . , X i k , where k ≤ k, such that X 0 = k j=1 X i j . Obviously, this corresponds to SET COVER, which hence gives an example of a monoid factorization problem which, when parameterized by k, is complete for W[2]. It might be interesting to investigate further implicitly given monoids from this parameterized perspective. We only mention as a last example from the literature PERMUTATION GROUP FACTORIZATION, which is known to be W[1]-hard but is lacking a precise classification; see Bodlaender et al. (1995), Downey and Fellows (2013). In the classical complexity context, we refer to Even and Goldreich (1981) (where the problem has the name MINIMUM GENERATOR SEQUENCE) and Jerrum (1985).
Let us also mention that from the 1980s onwards, Martin Beaudry and his colleagues led a whole research agenda, looking at what they called the MEMBERSHIP PROBLEM, which meant to look at special cases of MONOID FACTORIZATION; in many cases, they still obtain NP-hardness. We only mention here monoids with threshold (at least) two and point to Beaudry (1988Beaudry ( , 1994. 7 It should be noted that the question whether or not an upper bound on the length of the factorization is given makes a difference for various special cases if it comes to classical complexity. None of these monoid classes has been studied from the angle of parameterized complexity. Further problems of this type are discussed in Böhler et al. (2005). To the best of our knowledge, none of these has been examined from the viewpoint of parameterized complexity and hence give a number of open questions. To mention one concrete problem of this type: Let {c 1 , . . . , c m } be a collection of clauses, with variables {x 1 , . . . , x n }, and let k ∈ N. The question is if the empty clause can be derived within the resolution proof system within k resolution steps.
Let us finally remark that the discussion of implicit or explicit representations also extends to finite automata. Namely, it is well-known that the question if a given DFA accepts a word of length k is easy to check, while DFA-SW is NP-complete. Yet, we can build a DFA A from a DFA A with the classical power automaton construction, see Sandberg (2005), such that A accepts a word of length k if and only if A possesses a synchronizing word of length k. In other words, L(A ) can be viewed as an implicitly presented regular language. This type of presentation tends to make problems harder.

Open Questions and Concluding Thoughts
Throughout the paper, we already highlighted several concrete open questions. Let us now draw the reader's attention to three more general questions.  (2016), then all p 2 -problems would be as "easy" as SAT from an algorithmic point of view, something which contradicts at least the practical experience with this type of problems.
It is also interesting to observe that most of our problems come from the area of formal languages, in most cases, from automata theory. This area has been a bit neglected from the perspective of parameterized complexity, see Fernau (2019) for discussing further questions in this regard. Also, the class WNL mostly hosts formal language problems, as already exhibited by Guillemot (2011). It would be interesting to see further problems situated in WNL or in W[Sync] coming from other areas. As problems related to string problems can be found in computational biology and also in computational social choice, we expect these to be good candidate areas to look into in the future.