<p>The answer to this question depends very much on the definition of what a solution is. Take for example the <em>Vertex Cover</em> problem where we ask whether a graph <span class="math-container">$G$</span> has a vertex set <span class="math-container">$S$</span> of size at most <span class="math-container">$k$</span> such that every edge has an endpoint in <span class="math-container">$S$</span>. The natural definition of solution size is <span class="math-container">$k$</span>, the size of the vertex cover.</p>
<p>If you consider the dual parameter <span class="math-container">$\ell:n-k$</span> for <em>Vertex Cover</em>, then the problem is W[1]-complete since it is exactly the <em>Independent Set</em> problem. Using a strict definition of what a solution is, this gives an example of a problem that is W[1]-complete for a parameter that is not the solution size.</p>
<p>Now, we may define solution more loosely as some kind of certificate that can be verified efficiently. In that case, any parameterized problem that is in W[1] can be considered to be &quot;parameterized by the solution size&quot;: Take for example the characterization of W[1] due to Chen and Flum <a href="https://doi.org/10.1016/j.tcs.2005.02.003" rel="nofollow noreferrer">1</a>. This characterization states that a problem is in W[1] if it can be solved via a nondeterministic RAM that makes all its nondeterministic guesses in the last <span class="math-container">$h(k)$</span> computation steps for some function <span class="math-container">$h$</span>. It is clear from this definition that a problem in W[1] has a certficate and thus also a solution in the broad sense of size <span class="math-container">$h(k)$</span>.</p>
<p>So in short: It depends on what one views as a solution. If one takes a very strict view, then it is easy to come up with examples that are W[1]-complete for non-solution size parameters. If one takes a broad view of what a solution is, then a problem that is in W[1] for some parameter <span class="math-container">$k$</span> has, by definition, solutions (certificates) of size bounded in <span class="math-container">$k$</span>.</p>
<p><a href="https://doi.org/10.1016/j.tcs.2005.02.003" rel="nofollow noreferrer">Yijia Chen, Jörg Flum, Martin Grohe:
Machine-based methods in parameterized complexity theory. Theor. Comput. Sci. 339(2-3): 167-199 (2005)</a></p>

CC BY-SA 4.0
2020-11-13T09:46:05.847Z
Thanks for the first answer!
After reading your answer, I think I can better explain exactly what I am after using a specific problem and the issues I ran into. I just added the details to the original post as it would exceed the character limit of a comment...
Haden Hooyeon Lee
CC BY-SA 4.0
2020-11-13T10:50:41.713Z
I like the new part of the question but isn't this a new question? It asks for a concrete problem whether one can show containment in W[2] or hardness for W[3]. This differs a a bit from the original question.
Christian Komusiewicz
CC BY-SA 4.0
2020-11-13T12:28:16.313Z
Yes, I can ask about it as a new question, but I also wanted to related it to my original question; specifically this part: "I'm curious how one can show that X is in W[1] or W[2], e.g., when the size of a solution can still be "n" yet we can only choose "k" input gates as it seems impossible (how could you encode a large solution using only a (fixed) number of bits?). Even though X is known to be W[1]-hard or W[2]-hard, it may actually require circuits with large wefts than 2, for instance, if completeness is not known yet." The concrete question fits this, doesn't it?
Haden Hooyeon Lee
CC BY-SA 4.0
2020-11-12T12:27:14.257Z
2020-11-12T12:27:14.257Z
Christian Komusiewicz
<p>Note: Originally, this question was asked via <a href="https://cstheory.stackexchange.com/questions/47259/proving-membership-in-w-hierarchy-when-problem-is-not-parameterized-by-its-solut#comment105036_47259">a comment in this question</a>, but was asked to post a separate question. :)</p>
<p>I'm looking for any known reductions of the following:
Given a parameterized problem X (whose parameter is not the size of a solution and the size of a solution can still be quite large) showing X is W[t]-complete for some fixed t&gt;=1 (e.g., W[1]-complete, W[2]-complete, but not in FPT).</p>
<p>I'm curious how one can show that X is in W[1] or W[2], e.g., when the size of a solution can still be &quot;n&quot; yet we can only choose &quot;k&quot; input gates as it seems impossible (how could you encode a large solution using only a (fixed) number of bits?). Even though X is known to be W[1]-hard or W[2]-hard, it may actually require circuits with large wefts than 2, for instance, if completeness is not known yet.
(Or, perhaps such hardness as X cannot belong to W[t] for any fix t under (some conditions when the solution size is clearly not bounded by the parameter) may be implied in some cases, but I couldn't find any such results, either.)</p>
<p>Here are some problems that do not qualify:</p>
<ul>
<li>The independent set problem parameterized by tree width would be in FPT (although the solution size is not necessarily bounded by the parameter), so it won't qualify.</li>
<li>The clique problem parameterized by maximum degree of a vertex would also be in FPT (and in this case, the solution size would be bounded by the parameter anyway), so it won't qualify.</li>
<li>The vertex coloring problem (k-coloring) also won't qualify because it's para-NP-hard (i.e., it's not W[t] complete for any fixed constant, t), although its solution size is not bounded by the parameter k.</li>
</ul>
<hr />
<p>Update with details (Nov 13):</p>
<p>I now have a concrete problem that (I think) is W[2]-hard and in W[P],
but:
(1) I can't prove that this is in W[2] (so as to prove that it's W[2]-complete) and
(2) I also can't prove that this is W[3]-hard.</p>
<p>We are given <code>n</code> items and <code>m</code> bags (and some constraints to be specified), and we want to assign every item to some bag (subject to constraints below)
but only using up to <code>k</code> bags (here, '<code>k</code>' is the parameter).
Constraints are specified per item and bag pair:
For each item <code>i</code> and bag <code>j</code>, we are given two numbers <code>L(i, j)</code> and <code>U(i, j)</code> (lower-bound and upper-bound) in <code>[1, n]</code>
such that if we assign item <code>i</code> to bag <code>j</code>,
then the total number of items assigned to bag <code>j</code> must be between <code>L(i, j)</code> and <code>U(i, j)</code>, inclusive.
This must be satisfied for all items <code>i</code> in a solution.
(<code>L(i, j) &gt; U(i, j)</code> naturally implies that item <code>i</code> can't possibly be assigned to bag <code>j</code>.)</p>
<p>The input consists of <code>O(nm)</code> numbers (two numbers per pair), and a natural solution would be of size <code>O(n)</code>: For each item, we describe an index of the bag to which it is assigned.
On the other hand, a shorter certificate of size <code>k</code> also makes sense:
We can describe which <code>k</code> bags we use in a solution and how many items we assign to each of the said <code>k</code> bags.</p>
<p>To show that this problem is in <code>W[P]</code> (using the shorter certificate):</p>
<p>We need <code>2k</code> numbers as a certificate: <code>k</code> numbers for the bags used (their indices, <code>log m</code> bits each)
and another <code>k</code> numbers for how many items are assigned to each bag (<code>log n</code> bits each). We can non-deterministically guess these <code>2k</code> numbers,
and then solve a max-flow problem (or a bipartite matching problem) in poly-time.</p>
<p>To show that this problem is <code>W[2]</code>-hard:
We can reduce from the dominating set problem in a straightforward manner.
For each vertex, we create one item and one bag (so <code>n = m</code> in this reduction).
For each vertex <code>j</code> and its neighbors <code>i</code>,
we set <code>L(i, j) = 1</code> and <code>U(i, j) = n</code> (this means we can assign item <code>i</code> to bag <code>j</code>).
For all other <code>(i, j)</code> pairs (i.e., no edges), we set <code>L(i, j) &gt; U(i, j)</code> (so we can't assign <code>i</code> to <code>j</code>).
Clearly, we have a dom-set of size <code>k</code> if and only if we can assign <code>n</code> items to <code>k</code> bags.</p>
<p>The natural description of a solution (of size O(n)) is too large for me to reduce this problem to WCSAT where I can only set O(f(k)) input gates to true. On the other hand, a shorter certificate (that I used above) makes it too difficult to verify (the best I got is W[P] membership above). I realize that perhaps there are other, smarter &quot;short&quot; certificates of size O(f(k)),
and that is why I asked the question (to seek other problems/reductions for reference).
I haven't been lucky enough to find useful references yet...</p>

<parameterized-complexity><fixed-parameter-tractable>
Reducing Parameterized Problems (whose solution size can be "large") to W[i]-complete problems (for fixed i)
Haden Hooyeon Lee
# Reducing Parameterized Problems (whose solution size can be "large") to W[i]-complete problems (for fixed i)

(Asked by: username_0 on 2020-07-28)

Note: Originally, this question was asked via [a comment in this question](https://cstheory.stackexchange.com/questions/47259/proving-membership-in-w-hierarchy-when-problem-is-not-parameterized-by-its-solut#comment105036_47259), but was asked to post a separate question. :)

I'm looking for any known reductions of the following:
Given a parameterized problem X (whose parameter is not the size of a solution and the size of a solution can still be quite large) showing X is W[t]-complete for some fixed t>=1 (e.g., W[1]-complete, W[2]-complete, but not in FPT).

I'm curious how one can show that X is in W[1] or W[2], e.g., when the size of a solution can still be "n" yet we can only choose "k" input gates as it seems impossible (how could you encode a large solution using only a (fixed) number of bits?). Even though X is known to be W[1]-hard or W[2]-hard, it may actually require circuits with large wefts than 2, for instance, if completeness is not known yet.
(Or, perhaps such hardness as X cannot belong to W[t] for any fix t under (some conditions when the solution size is clearly not bounded by the parameter) may be implied in some cases, but I couldn't find any such results, either.)

Here are some problems that do not qualify:

* The independent set problem parameterized by tree width would be in FPT (although the solution size is not necessarily bounded by the parameter), so it won't qualify.
* The clique problem parameterized by maximum degree of a vertex would also be in FPT (and in this case, the solution size would be bounded by the parameter anyway), so it won't qualify.
* The vertex coloring problem (k-coloring) also won't qualify because it's para-NP-hard (i.e., it's not W[t] complete for any fixed constant, t), although its solution size is not bounded by the parameter k.

---

Update with details (Nov 13):

I now have a concrete problem that (I think) is W[2]-hard and in W[P],
but:
(1) I can't prove that this is in W[2] (so as to prove that it's W[2]-complete) and
(2) I also can't prove that this is W[3]-hard.

We are given `n` items and `m` bags (and some constraints to be specified), and we want to assign every item to some bag (subject to constraints below)
but only using up to `k` bags (here, '`k`' is the parameter).
Constraints are specified per item and bag pair:
For each item `i` and bag `j`, we are given two numbers `L(i, j)` and `U(i, j)` (lower-bound and upper-bound) in `[1, n]`
such that if we assign item `i` to bag `j`,
then the total number of items assigned to bag `j` must be between `L(i, j)` and `U(i, j)`, inclusive.
This must be satisfied for all items `i` in a solution.
(`L(i, j) > U(i, j)` naturally implies that item `i` can't possibly be assigned to bag `j`.)

The input consists of `O(nm)` numbers (two numbers per pair), and a natural solution would be of size `O(n)`: For each item, we describe an index of the bag to which it is assigned.
On the other hand, a shorter certificate of size `k` also makes sense:
We can describe which `k` bags we use in a solution and how many items we assign to each of the said `k` bags.

To show that this problem is in `W[P]` (using the shorter certificate):

We need `2k` numbers as a certificate: `k` numbers for the bags used (their indices, `log m` bits each)
and another `k` numbers for how many items are assigned to each bag (`log n` bits each). We can non-deterministically guess these `2k` numbers,
and then solve a max-flow problem (or a bipartite matching problem) in poly-time.

To show that this problem is `W[2]`-hard:
We can reduce from the dominating set problem in a straightforward manner.
For each vertex, we create one item and one bag (so `n = m` in this reduction).
For each vertex `j` and its neighbors `i`,
we set `L(i, j) = 1` and `U(i, j) = n` (this means we can assign item `i` to bag `j`).
For all other `(i, j)` pairs (i.e., no edges), we set `L(i, j) > U(i, j)` (so we can't assign `i` to `j`).
Clearly, we have a dom-set of size `k` if and only if we can assign `n` items to `k` bags.

The natural description of a solution (of size O(n)) is too large for me to reduce this problem to WCSAT where I can only set O(f(k)) input gates to true. On the other hand, a shorter certificate (that I used above) makes it too difficult to verify (the best I got is W[P] membership above). I realize that perhaps there are other, smarter "short" certificates of size O(f(k)),
and that is why I asked the question (to seek other problems/reductions for reference).
I haven't been lucky enough to find useful references yet...

**Tags:** parameterized-complexity, fixed-parameter-tractable


---

## 1 answers

### Answer by username_1 on 2020-11-12. Score: 3 | Accepted answer

The answer to this question depends very much on the definition of what a solution is. Take for example the *Vertex Cover* problem where we ask whether a graph $G$ has a vertex set $S$ of size at most $k$ such that every edge has an endpoint in $S$. The natural definition of solution size is $k$, the size of the vertex cover.

If you consider the dual parameter $\ell:n-k$ for *Vertex Cover*, then the problem is W[1]-complete since it is exactly the *Independent Set* problem. Using a strict definition of what a solution is, this gives an example of a problem that is W[1]-complete for a parameter that is not the solution size.

Now, we may define solution more loosely as some kind of certificate that can be verified efficiently. In that case, any parameterized problem that is in W[1] can be considered to be "parameterized by the solution size": Take for example the characterization of W[1] due to Chen and Flum [1](https://doi.org/10.1016/j.tcs.2005.02.003). This characterization states that a problem is in W[1] if it can be solved via a nondeterministic RAM that makes all its nondeterministic guesses in the last $h(k)$ computation steps for some function $h$. It is clear from this definition that a problem in W[1] has a certficate and thus also a solution in the broad sense of size $h(k)$.

So in short: It depends on what one views as a solution. If one takes a very strict view, then it is easy to come up with examples that are W[1]-complete for non-solution size parameters. If one takes a broad view of what a solution is, then a problem that is in W[1] for some parameter $k$ has, by definition, solutions (certificates) of size bounded in $k$.

[Yijia Chen, Jörg Flum, Martin Grohe:
Machine-based methods in parameterized complexity theory. Theor. Comput. Sci. 339(2-3): 167-199 (2005)](https://doi.org/10.1016/j.tcs.2005.02.003)

> **Comments:**
> **username_0**: Thanks for the first answer! After reading your answer, I think I can better explain exactly what I am after using a specific problem and the issues I ran into. I just added the details to the original post as it would exceed the character limit of a comment...  
> **username_1**: I like the new part of the question but isn't this a new question? It asks for a concrete problem whether one can show containment in W[2] or hardness for W[3]. This differs a a bit from the original question.  
> **username_0**: Yes, I can ask about it as a new question, but I also wanted to related it to my original question; specifically this part: "I'm curious how one can show that X is in W[1] or W[2], e.g., when the size of a solution can still be "n" yet we can only choose "k" input gates as it seems impossible (how could you encode a large solution using only a (fixed) number of bits?). Even though X is known to be W[1]-hard or W[2]-hard, it may actually require circuits with large wefts than 2, for instance, if completeness is not known yet." The concrete question fits this, doesn't it?  

---

