Between the deterministic and non-deterministic query complexity

TL;DR

This paper explores the spectrum of query complexities between deterministic and non-deterministic models, introducing intermediate measures and providing bounds for various problems to understand their query requirements.

Contribution

It introduces a new hierarchy of query complexities $D_k(P,n)$ between deterministic and non-deterministic cases, with bounds for different problems.

Findings

Established bounds for $D_k(P,n)$ across multiple problems.

Defined a hierarchy of query complexities interpolating between known extremes.

Provided insights into how input modifications affect query complexity.

Abstract

We consider problems that can be solved by asking certain queries. The deterministic query complexity $D(P,n)$ of a problem $P$ is the smallest number of queries needed to ask in order to find the solution with an input of size $n$ (in the worst case), while the non-deterministic query complexity $D_0(P,n)$ is the smallest number of queries needed to ask, in case we know the solution, to prove that it is indeed the solution (in the worst case). Equivalently, $D(P,n)$ is the largest number of queries needed to find the solution in case an Adversary is answering the queries, while $D_0(P)$ is the largest number of queries needed to find the solution in case an Adversary chooses the input. We define a series of quantities between these two values, $D_k(P,n)$ is the largest number of queries needed to find the solution in case an Adversary chooses the input, and answers the queries, but he can change the input at most $k$ times. We give bounds on $D_k(P,n)$ for various problems $P$.

Full text

We define a series of quantities between these two values, $D_{k}(P)$ is the largest number of queries needed to find the solution in case an Adversary chooses the input, and answers the queries, but he can change the input at most $k$ times. We give bounds on $D_{k}(P)$ for various problems $P$.

1 Introduction

In this paper, we consider problems that can be solved by asking certain queries. Somewhat loosely, a problem consists of a function and some kind of description of allowed queries. We are given a function $f:X\rightarrow Y$. $X$ is the set of inputs, and our goal is to determine $f(x)$ for an unknown $x\in X$. We can ask queries of certain type in order to do that. We need to construct an algorithm, i.e. a strategy that describes what is the next query after a series of queries and answers. This can be represented by a decision tree, a tree where the vertices are potential queries, the first query is the root, the possible answers to a query are represented by edges going out from the corresponding vertex, and at the other end of an edge we have the next query.

The most typical goal is to find algorithms that minimize the worst case query complexity $D(P,n)$ of a problem $P$, i.e. the maximum number of queries that the algorithm needs to ask to solve the problem on an input of size $n$.

A useful approach is to consider the problem as a game between a player who asks the queries and tries to solve the problem as fast as possible (we will call him Questioner), and another player, usually called Adversary, who answers the queries and tries to postpone the solution. Rather than choosing an input element $x\in X$, the Adversary can answer arbitrarily. However, his answers have to be consistent with at least one input. The game finishes if Questioner can find the value of $f$, assuming that the answers are consistent with at least one input.

Assume that we can find an algorithm for the Adversary such that no matter what strategy the Questioner has, at least $m$ queries have to be asked before the game finishes. Then it is easy to see that $D(P,n)\geq m$. Indeed, against any particular strategy of the Questioner, the Adversary’s answers are consistent with an input $x$. That means the particular strategy needs to ask at least $m$ queries if $x$ happen to be the input, and this holds for every strategy, thus $D(P,n)\geq m$.

On the other hand, even the best strategy for the Adversary cannot force Questioner to ask more than $D(P,n)$ queries.

Above we were looking for the algorithm that minimized the number of queries for the worst input, i.e. the minimum (among algorithms) of the maximum (among inputs) of the queries needed to solve the problem for that input. One can look instead for the maximum (among inputs) of the minimum (among algorithms) of the queries needed. In other words, previously we evaluated algorithms based on the worst input, and picked the best algorithms, but now we are going to evaluate inputs based on the best algorithm, and then pick the worst input.

A more typical approach to this version is that we can guess the input $x$, but we still have to prove that the value of $f$ is indeed $f(x)$. Our knowledge on $x$ only helps us choose the queries that we ask. It is called the non-deterministic version of the problem. In the decision tree, it means that instead of the longest path from a root to a leaf, we are looking for the shortest such path. Its length is called the non-deterministic query complexity or certificate complexity of the problem, and we denote it by $D_{0}(P,n)$. Note that non-deterministic complexity is usually defined in a non-symmetric way. In particular, if $f$ has only two possible values 0 or 1, it is possible that for every $x$ with $f(x)=0$, the proof of this fact is short, while for some $y$ with $f(y)=1$, the proof of this fact is long.

If we consider the problem as a game, the change is that Adversary has to pick the input $x$ immediately. Earlier we looked for the number of queries needed if both players play optimally. Now we still have the same assumption, Questioner plays optimally, and the Adversary has to choose the input that gives the largest number of queries. We can look at the optimal play of the Questioner, as if he knows (because he guessed correctly) the input.

One can look at Adversary strategies in the deterministic version the following way. Instead of saying that the Adversary does not have to pick the input, we can say that he has to pick one, but he can change it. Of course, when the input is changed, the new one has to be consistent with all the earlier answers.

In this paper we are going to limit the Adversary’s ability. We are going to assume that the input can be changed at most $k$ times. We remark that the earlier answers to the queries have to be satisfied, we say that those are fixed. We call the set of steps between two changes of the input rounds.

We are going to look at the game from the Adversary’s point of view. If we are interested in the best case for the Adversary (i.e. the worst case for the Questioner), then by the above arguments, $D(P,n)$ queries are needed to finish the game if he can change the input arbitrarily and $D(P,n)$ queries are needed to finish the game if he cannot change the input at all.

Hence we are interested in the worst case for the Adversary. We denote this problem by $P(k)$ and the number of queries needed in this case (with an input of size $n$) by $D_{k}(P,n)$. We assume Questioner asks the best possible queries all the time. Therefore; we can assume the Questioner actually knows all the time, what the current input is, and his goal is not to find the value of $f$, but to prove that it is that value (i.e. to find a certificate). In particular, if $k=0$, then Adversary does not play after choosing $x$, and Questioner knows $x$. This is indeed the non-deterministic version, thus we do not denote two different things by $D_{0}(P,n)$.

On the other hand, if $k\geq D(P,n)-1$, then the Adversary can change the input as much as he wants in the first $D(P,n)-1$ steps, and the best strategy of Questioner ends before any further chance for the Adversary to change the input. Thus we have $D_{k}(P,n)=D(P,n)$ if $k\geq D(P,n)-1$.

The above observations show that for any $k$, $D_{k}(P,n)$ is between the non-deterministic and the deterministic complexity of the problem $P$. We continue with two other simple observations.

Proposition 1.1**.**

(i) $D_{k}(P,n)\leq D(P,n)$.

(ii) $D_{k}(P,n)\leq\min\{\sum_{i=1}^{l}D_{j_{i}}(P,n):\sum_{i=1}^{l}(j_{i}+1)>k\}$.

Proof.

$D(P,n)$ is an upper bound by definition. To show (ii), the Questioner runs the optimal algorithm for $P(j_{1})$. If it does not solve the problem, the Adversary had to change the input more than $j_{1}$ times. Then the Questioner runs the optimal algorithm for $P(j_{2})$, and so on till $P(j_{l})$. If the problem is never solved, in each part the Adversary had to change the input at least $j_{i}+1$ times, thus altogether more than $k$ times, a contradiction. ∎

Proposition 1.2**.**

$D_{k}(P,n)\geq\min\{k+1,D(P,n)\}$.

Proof.

Let Strategy $A$ of the Adversary be one that forces at least $D(P,n)$ questions in the non-restricted case. Let us assume first $k+1\geq D(P,n)$. Then the Adversary has the freedom to change the input in the first $D(P,n)-1$ steps, thus he can follow Strategy $A$. If $k+1<D(P,n)$, then the Adversary follows the same strategy. He can lose only when he cannot change the input anymore, thus no earlier than after the $k+1$’st query. ∎

Motivation

We have multiple different ways to look at the new question initiated here, and they lead to different motivations and different terminology.

Our main motivation is to understand the difference between deterministic and non-deterministic query complexity more, by examining what happens in the middle ground.

If we consider the problem as a game, we can look at the non-deterministic version, where the Adversary has to pick an input. If we look at the deterministic version afterwards, we can consider Adversary’s strategy of changing the input as cheating. For example, in the well-known game of Battleship, a player can rearrange his ships without the opponent noticing. This is useful (in increasing the number of guesses needed to sink all the ships from $D_{0}(P,n)$ to $D(P,n)$), but it is obviously cheating. In this setting, we study the limitations of cheating. Note that in this setting the Questioner also cheats by peeking.

In a sense, we also study how robust our algorithms are. When we look at the optimal algorithms, not just the values of $D_{k}(P,n)$, we can see how much we have to change them if the input changes.

Let us mention that it is not unimaginable that we meet our problem when examining actual algorithms. It is not unusual that we have a strong assumption on the input. Yet a query can have an unexpected answer. That results in a paradigm shift, a complete reevaluation of the input, which leads to a new, equally strong assumption. Assuming there are at most $k$ paradigm shifts is very unnatural, but assuming there are not too many shifts makes sense.

Finally, we can look at our problems from a different angle. Instead of having a fixed input, we are given a dynamic, ever-changing system. When we ask a query, rather than getting an existing (but unknown to us) information about the input, we fix that part of the input. We do have some knowledge about the parts not yet fixed, but it is unreliable. Still, we may be able to assume that our knowledge is rarely wrong.

Structure of the paper

In the next sections, we study $D_{k}(P,n)$ for different problems $P$. We consider search theory and group testing in Section 2, sorting in Section 3, finding the largest and the smallest element in a set with an unknown order in Section 4, and the property that a graph is connected in Section 5. We finish the paper with concluding remarks, where we describe a couple variants.

2 Search theory and group testing

In search theory, $f=id$ is the identity function, i.e. we need to identify an unknown element $x$ from an underlying set of size $n$ (the set of possible inputs). Usually $x$ is called the defective element, that causes failures in the whole system and our goal is to locate the defective part. The allowed queries are all the possible YES/NO questions. Every such query we identify with the set of elements where the answer is YES, thus we ask subsets of the underlying set. In particular, the Questioner can ask the set $\{x\}$, showing $D_{0}(P,n)=1$.

On the other hand, it is well-known that $D(P,n)=\lceil\log n\rceil$. Thus Proposition 1.1 and Proposition 1.2 (with $j_{1}=\dots=j_{k+1}=0$) imply $D_{k}(P,n)=\min\{k+1,\log n\}$.

A natural generalization is to consider the case there are more than one defectives. This version is usually called group testing. For more on this area, see [1]. In this case the input is a set of elements. Usually we assume that there are exactly $d$ or at most $d$ defectives. Let us denote these problems by $P_{d}$ and $P_{\leq d}$. It is well-known that we have $\Omega(d\log(n/d))=D(P_{d}),D(P_{\leq d})=O(d\log n)$ (see for example [1]).

Observe fist that $D_{0}(P_{d},n)=1$ by asking the complement of the set of defectives, but $D_{0}(P_{\leq d},n)=\min(d,n)$. Indeed, it is enough to ask the sets $\{a\}$ for all the defective elements $a$. On the other hand, for every defective element $a$ we need to ask a set that contains only $a$ among the defective elements, otherwise $a$ could be non-defective. For general $k$ we have $D_{k}(P_{d},n)=\min\{k+1,D(P_{d},n)\}$ using Proposition 1.1 and Proposition 1.2 with $j_{1}=\dots=j_{k+1}=0$.

The situation, however, is much more complicated for $P_{\leq d}$. The same way, using Propositions 1.1 and 1.2, we obtain the lower bound $\min\{k+1,D(P_{\leq d},n)\}$ and the upper bound $\min\{k+d,D(P_{\leq d},n)\}$. If $n$ is small, this difference disappears, as $D(P_{\leq d})$ gives the minimum in both bounds. We show that if $n$ is large, the upper bound is the truth.

Proposition 2.1**.**

Let $n>(d-1)2^{k}$. Then $D_{k}(P_{\leq d},n)=k+d$.

Proof.

The upper bound is given by the above observations. For the lower bound, consider the following simple algorithm of the Adversary. For the first query $A$, he answers YES if and only if $|A|\geq n/2$. Moreover, he gives the additional information that all the defective elements are in $A$ in this case. Thus after the answer all we know is a set of size at least $n/2$ that contains all the defectives. He answers the same way for the first $k$ queries, after that there is a set of size at least $n/2^{k}>d-1$ that contains all the defectives. Even if the Adversary used up all the possible changes of the input, the Questioner needs at least $d$ more queries to identify all the defectives.

∎

3 Sorting

In the case of sorting, the input is a set of $n$ different numbers $a_{1},\dots,a_{n}$, and a query corresponds to two numbers $a_{i}$ and $a_{j}$ with answer YES if and only if $a_{i}<a_{j}$. The goal is to sort the elements, i.e. find the increasing order of them. One can look at it as a special version of the search theory problem studied in Section 2, as we are identifying one of many possible orderings. However, instead of every possible YES/NO questions, we can only ask some special ones. For more on sorting, see for example [2].

Let $S$ denote the sorting problem, then it is well-known that $D(S,n)=O(n\log n)$. On the other hand, $D_{0}(S,n)=n-1$. Indeed, one can ask the largest and the second largest element, then the second largest and the third largest, and so on. On the other hand, the queried pairs as edges form a graph, and if that graph is unconnected, we cannot know how their vertices relate to each other.

An important special property of this problem is that those $n-1$ edges are always needed to solve the problem, as if two adjacent numbers are not asked as a query, we have no way to show which one is larger. The other $\binom{n-1}{2}$ possible queries are ultimately useless. Hence the Adversary’s goal with the changes is to make sure that not too many of these edges are among the queries already asked.

Proposition 3.1**.**

$D_{1}(S,n)=\lceil 3n/2\rceil-2$.

Proof.

Let us start with the strategy of the Adversary. He answers the first $\lceil n/2\rceil-1$ queries without change. Then he changes the input such a way that none of the queried pairs have two adjacent vertices, thus $n-1$ further queries are needed.

We need to show that the elements can be reordered in the above described way. The queried edges form a graph, with a partial ordering on every connected component. The Adversary extends the partial ordering to an arbitrary total ordering on each connected component. Let $a_{1}<\dots<a_{k}$ be a largest component, and consider the largest set of components with less than $k$ elements. The Adversary extends the ordering on those components to a total ordering $b_{1}<\dots<b_{\ell}$, and let $a_{i}<b_{i}<b_{i+1}$ for every $i\leq\ell$. For every other component with ordering $c_{1}<\dots<c_{m}$, he lets $a_{k-i}<c_{i}<a_{k-i+1}$ for $i\leq m$. Finally, he extends the ordering give above to a total ordering and gives this as the new input.

For $a_{i}$ and $a_{j}$ with $i<j$, we have either $b_{i}$ or $c_{k-i}$ between them in the new ordering. For every pair of vertices from another component, an $a_{i}$ is between them. This shows that for any of the first $\lceil n/2\rceil-1$ queries, the two elements are not adjacent in the new input, thus $n-1$ further queries are needed.

Let us continue with the strategy of the Questioner. He tries to follow his strategy for the non-deterministic version of the problem, described above: in query $i$ he asks the $i$th and $i+1$st smallest element, until Adversary executes the change. Assume it happens after the $i$th answer, then we have a total ordering of $i+1$ elements $b_{1}<\dots<b_{i+1}$. After the change, for each other element we know its final place in the ordering, in particular we know how many elements are between $b_{j}$ and $b_{j+1}$. If there are $p$ elements between $b_{j}$ and $b_{j+1}$, then $p+1$ queries are enough to prove that their final places are what we suspect. If there are $p$ elements smaller than $b_{1}$ (or larger than $b_{i+1}$), then $p$ queries are enough for the same.

This shows that we can find the place of the remaining $n-i-1$ elements with one query for each plus some extra queries. On the one hand, at most $i-1$ extra queries are needed (thus $n-2$ altogether), because there are $i-1$ intervals where we might need extra queries. On the other hand, at most $n-i-1$ extra queries are needed, as we need at least one element between $b_{j}$ and $b_{j+1}$ for an extra query. Thus $D_{1}(S,n)\leq\min\{i+n-2,i+2(n-i-1)\}$, which easily implies the statement. ∎

Let us briefly discuss $D_{k}(S,n)$. A reasonable algorithm for the Questioner is the straightforward generalization of the above. He looks at the current input $a_{1}<\dots<a_{n}$ and asks $a_{i},a_{i+1}$ for the smallest $i$ this query has not been asked.

Against this strategy the Adversary can do the following. He changes after $\ell_{1}$ queries, and places the elements not queried yet in a balanced way between the elements appearing in earlier queries. Then the $i$th change is applied after $\ell_{i}$ queries, and the last change is at the last point where he can change the input so that none of the pairs queried earlier are adjacent in the new input, thus $n$ further queries are needed afterwards. Then at each point the ordering that is fixed is (with a small error) $b_{1}\dots<b_{p}<c_{1}\dots<c_{q}$, such that in the current ordering the $b_{i}$s (those elements asked in the current round) are the $p$ smallest element, and the $c_{i}$s are above them, divided in a balanced way. The last change has to come when $p+q$ is about $n/2$, thus the extra queries are won in earlier rounds. However, an exact analysis of this would be rather complicated, because of the errors mentioned earlier. Indeed, at a given change the earlier queries gave the ordering $a_{1}<\dots<a_{r}$, and whenever later we ask queries containing elements that are between $a_{i}$ and $a_{i+1}$ in the current ordering, the largest becomes $b_{p}$, while $c_{1}=a_{i+1}$. However, we do not know if the relation $b_{p}<c_{1}$ holds in every ordering. This gives a small error, that might add up during the rounds.

4 Finding the maximum and the minimum

A simpler task than the one considered in the previous section is, having the same input and queries, to look for only some special elements. Finding the largest element takes $n-1$ queries both in the deterministic and the non-deterministic way. Indeed, every other element has to be the smaller in an answer, thus $n-1$ queries are needed, and it can be easily achieved by not asking any element that has no chance to be the largest, since it was proved to be smaller than another element earlier. This implies that with any number of changes, $n-1$ queries are needed.

Obviously, the same holds finding the smallest element. Let $L$ denote the problem of finding the largest and the smallest element at the same time. Pohl [4] proved that $D(L,n)=\lceil 3n/2\rceil-2$. It is obvious that $D_{0}(L,n)=n-1$. The lower bound comes from the fact that it is obviously not easier than finding only the largest element, while the queries needed to ask are those of the form $a_{i},a_{i+1}$, where $a_{i}$ is the $i$th largest element. Observe that these queries are the only certificate of size $n-1$. Indeed, every element but $a_{1}$ should be the smaller, and every element but $a_{n}$ should be the larger in a query. These are $2n-2$ fixed positions, thus no element can be larger (or smaller) in more than one query if we have only $n-1$ queries. Obviously $a_{2}$ is only smaller than $a_{1}$, thus the query $a_{1},a_{2}$ has to be present. Then $a_{3},a_{1}$ cannot be asked, thus $a_{3},a_{2}$ can be the only query where $a_{3}$ is the smaller, hence it has to be asked, and so on.

Theorem 4.1**.**

$D_{k}(L,n)=\min\{n+k-1,\lceil 3n/2\rceil-2\}$.

Proof.

First we prove $D_{k}(M,n)\leq n+k-1$. Observe that this, together with $D(M,n)=\lceil 3n/2\rceil-2$ proves $D_{k}(L,n)\leq\min\{n+k-1,\lceil 3n/2\rceil-2\}$. We use induction on $k$, the base case $k=0$ was described above. In the first round, the Questioner asks $a_{i},a_{i+1}$ as the $i$th query, where $a_{i}$ is the $i$th largest element. Assume there is a change after the $j$th query. Then we know $a_{2},\dots,a_{j}$ cannot be the largest, nor the smallest elements. Thus we need to find the largest and smallest element among the other ones, hence $D_{k-1}(L,n-j+1)=n-j+k-1$ further queries are enough.

We continue with the Adversary’s strategy. We say that an element is out if it was both smaller and larger in queries. During the first part of the algorithm, the Adversary answers such a way that no element goes out, whenever he can. In this case he also changes the input the following way. Assume $A$ is the set of elements that are out, $B$ is the set of elements that are not out and were smaller in a query, and $C$ is the set of elements that are not out and were larger in a query (and there is a set $D$ of $n-|A|-|B|-|C|$ elements that have not appeared in a query). Then in the new input the elements of $B$ are the smallest, then come the elements of $A$ and $D$, and finally the elements of $C$. Note that any such ordering is consistent with the answers so far, except for the ordering inside $A$.

This part ends after $\min\{k,\lceil n/2\rceil\}$ such answers (thus after at most $k$ changes). If, during this part the Adversary has to answer such a way that an element is out (because two elements of $B$ or two elements of $C$ are queried), then he answers without changing the input. In the second part, he does not change the input anymore.

Assume first there is no second part, the algorithm ends after at most $\min\{k,\lceil n/2\rceil\}$ answers where no element goes out. As at most $n-2$ elements go out, we are done in this case. Assume now there is a second part. Then there are $\min\{k,\lceil n/2\rceil\}+|A|$ queries in the first part. In the second part, all but one element of $B$ has to be larger in a query, and all but one element of $C$ has to be smaller in a query. These all require distinct queries, as the elements of $B$ are smaller than the elements of $C$ in the current input. Thus we have at least $\min\{k,\lceil n/2\rceil\}+|A|+|B|-1+|C|-1$ queries. ∎

5 Connected graphs

The input is an unknown graph $G$ on $n$ vertices, the allowed queries correspond to pairs of vertices $u,v$, and the answer tells if $uv$ is an edge of $G$ or not. Let $C$ denote the problem of finding out if $G$ is connected or not.

It is well-known (see for example [3]) that $D(C)=\binom{n}{2}$, i.e. the connectedness is an evasive graph property. In other words, Questioner has to ask all the pairs and completely identify the graph $G$ in order to find out if it is connected. A simple strategy of the Adversary that shows this is the following. He answers NO to every query unless it would make the graph unconnected. This shows $D_{n-2}(f)=\binom{n}{2}$, as there are always $n-1$ YES answers in this strategy, and the last one arrives after the last query.

On the other hand, $D_{0}(f)=\lfloor n^{2}/4\rfloor$. Indeed, the Adversary can choose a graph $G$ consisting of two components of size $\lfloor n/2\rfloor$ and $\lceil n/2\rceil$. Then $G$ is unconnected, but to show this, one has to ask all the possible edges between the two components.

Let $T(n,k)$ denote the Turán graph, i.e. the $k$-partite complete balanced graph on $n$ vertices, and $t(n,k)$ denote the number of its edges. Here balanced means every part has size $\lfloor n/k\rfloor$ or $\lceil n/k\rceil$. Note that this graph has to most number of edges among $k$-partite graphs.

Theorem 5.1**.**

$t(n,k+2)\leq D_{k}(C,n)\leq t(n,k+2)+n-1$.

Proof.

Let us start with the Adversary’s strategy. He chooses as the original input the complement $G$ of the Turán graph. Let $A_{1},\dots,A_{k+2}$ be the parts in the Turán graph; they are cliques in $G$. He always answers that vertices in the same $A_{i}$ are connected; in fact he gives this information for free, and in the followings we consider those edges to be known. The Adversary changes the input whenever the NO answer would make the graph unconnected (and would finish the algorithm). In that situation he changes the current non-edge to an edge. This way the graph will be not connected at the end, but the last change makes the graph have only two components. Assume an edge $uv$ of the Turán graph has not been asked. Then at the end of the algorithm $u$ and $v$ cannot be in the same component. Indeed, in that case there was a query $u^{\prime}v^{\prime}$ at one point that connected two components, one of them having $u$ and the other having $v$. But then the answer would have been no to that query, as it does not make the graph unconnected. Thus $u$ and $v$ are in different components, but then the graph could be connected, a contradiction.

For the upper bound, we apply induction on $k$, the base step $k=0$ is described before the theorem is stated. Note that if $k\geq n-2$, the upper bound is larger than $\binom{n}{2}$, thus the statement is trivial. Hence from now on we assume $k\leq n-3$.

Let us describe the Questioner’s strategy. First, he asks the edges of a spanning forest. Whenever the current graph does not have a spanning forest of edges already asked, he picks the smallest number of edges that would form a spanning forest with some of the edges we know are in the graph. Whenever the current graph has such an edge, he picks the smallest cut and asks its edges.

Claim 5.2**.**

After finding a spanning forest (of the graph $G^{\prime}$ that is the input graph at that point), if there are $i$ changes left, at most $t(n,i+2)$ queries are needed.

Proof of Claim.

Observe first that each of the connected components of $G^{\prime}$ contains a spanning tree. If there are at most $i+2$ connected components of $G^{\prime}$, then (as it is pointless to ask edges with both endpoints in the same component) the number of queries we need to ask cannot be more than the number of edges in the complement graph of $G^{\prime}$, which is at most $t(n,i+2)$.

If there are more than $i+2$ components of $G^{\prime}$, let $a_{1},\dots,a_{i+1}$ be the size of the components we try to separate from the remaining vertices, and let $a_{i+2}=n-\sum_{j=1}^{i+1}a_{j}$. Then the number of queries we ask after finding the spanning tree is at most $\prod_{1\leq j<l\leq i+2}a_{j}a_{l}$, which is the number of edges in the complete $(i+2)$-partite graph with parts of size $a_{j}$, thus at most $t(n,i+2)$. ∎

Let us return to the proof of the theorem. If there is no change while finding the spanning forest, then the above claim finishes the proof.

If there is a change during the queries corresponding to the very first spanning forest, then we continue till we find a spanning forest, by asking edges that are present in the current input graph, but are not inside a connected component of the known edges. Observe that after at most $n-1$ YES answers, we have a spanning forest in the current graph. If we had $k-i$ NO answers during that, that means $k-i$ changes, thus at most $t(n,i+2)$ queries are needed afterwards, by the above claim. This means there are $n-1+k-i+t(n,i+2)$ querues altogether. Observe that $t(n,i)<t(n,i+1)$, whenever $i<n$. This implies $k-i+t(n,i+2)\leq t(n,k+2)$, whenever $k\leq n-2$, finishing the proof. ∎

6 Concluding remarks

We have defined a quantity that is between the deterministic and non-deterministic query complexity. We studied it for a couple examples, but there are countless many other, equally interesting questions. Also, we were unable to completely determine $D_{k}(P,n)$ even for most of the problems we considered.

Here we describe some potential variants of the model we have studied.

In the graph case, or more generally if the input is disjoint union of the possible queries (for example in case of any kind of Boolean functions), one could restrict the change to the query being asked. Note that in fact this is how the Adversary changes the input graph in Theorem 5.1 anyway. For this model, we can consider the following motivation: Questioner has some outdated information, for example a map, and some things have changed since that was published. However, it is a reasonable assumption that there was a limited number of changes. Also the changes are independent, i.e. when we learn our information was incorrect at one place, we have no reason to assume any particular other change (compare this to the bigger paradigm shifts in one of the motivations of the model studied in this paper).

The changes in our study are in some sense opposite to lies in other studies. There the Adversary has a different option: he can give arbitrary false answers at most $l$ times. This is in addition to his ability to change the input as many times as he wants it. Still, it would be interesting to combine these abilities and study an Adversary who can change the input $k$ times and lie $l$ times. In this case we would not assume the Questioner knows everything.

There are other models of lies, when a fixed proportion of the answers can be false, or when every answer is false with a probability $p$, independently from each other. Similarly, we could modify our model and allow changes proportional to the number of queries, or define a distribution on the possible input graphs at every point, and choose one randomly.

We could also combine changes and lies in a more complicated way. For example, the Adversary could tell that an earlier answer of his was a lie, because he changed the input at that point.

Funding: Research supported by the National Research, Development and Innovation Office - NKFIH under the grants SNN 129364, KH 130371 and K 116769 and by the János Bolyai Research Fellowship of the Hungarian Academy of Sciences.