2. Proof outline

The proof of Theorem 1.1 can be broken up in two main steps. In the first step, contained in Section 3, we reduce the traditional form of Mastermind to what we call signed permutation Mastermind. This can be described as the variation of Mastermind on $n$ positions and colours where

1. 1. codemaker is restricted to choosing the codeword $c$ to be a permutation of $[n]$ , and

2. 2. codebreaker can make signed queries $q\in \{-n, \dots n\},$ where, after each query, codemaker must respond with the value

   \begin{equation*}\hat {b}(q) = \hat {b}_c(q) \;:\!=\; |\{i \in [n] | c_i = q_i \}| - |\{i \in [n] | c_i = - q_i \}| .\end{equation*}

In other words, codebreaker can decide, for each position in a query, whether a correct guess should count as a $+1$ or as a $-1$ . Note also that codebreaker can choose to leave an entry in a query “blank” by giving it the value $0$ , in which case it will never contribute to the returned value.

This is all done in preparation for the second step, contained in Section 4, where we take a more constructive approach and recursively as well as deterministically provide a set of adaptive queries that give the answer to the signed permutation Mastermind problem.

Our approach to determining the codeword in this version of Mastermind can be described as resolving $\mathcal{O}(n \log n)$ subtasks of the form “Given that a colour $x$ is present in an interval $I$ , determine whether $x$ is present in the left or right half of $I$ ”. In other words, we attempt a binary search for each colour. We can make such a task part of a query by putting $q_i=x$ for all indices $i$ in the left half of $I$ , and putting $q_i=0$ in all indices $i$ in the right half of $I$ . Then this will contribute a with $+1$ to the answer of the query if colour $x$ is in the left half of $I$ , and $0$ and if $x$ is in the right half of $I$ . Clearly, a single task can be resolved after a single query, however the challenge is to find a way to resolve these tasks by performing only $\mathcal{O}(n)$ queries.

Similar to the algorithm by Doerr, Doerr, Spöhel, and Thomas [Reference Doerr, Doerr, Spöhel and Thomas4], we will base our solution on coin-weighing schemes. Here, we think of the $\mathcal{O}(n \log n)$ tasks described above as our coins, where a coin has the value $1$ if the colour in the corresponding task is present in the left half of its interval, and $0$ otherwise. Weighing a collection of coins together corresponds to making one query where each of the corresponding tasks is encoded as described above. Note that if there were no further restrictions on how tasks could be queried together, then any of the classical solutions to coin-weighing would let us resolve the $\mathcal{O}(n \log n)$ tasks in $\mathcal{O}( n \log n/ \log ( n \log n)) = \mathcal{O}(n)$ queries, which is the conclusion we want, but under far too weak assumptions. The classical coin-weighing problem assumes that any collection of coins can be weighed together. This is far from true in the problem at hand. First, we cannot encode two tasks into the same query if their corresponding intervals overlap. Second, tasks depend on each other in the sense that certain tasks are only available for querying after another task is resolved. For instance, we cannot query in which quarter of the codeword the colour red is present until we have first determined in which half of the codeword it is in. This is of particular concern for tasks corresponding to big intervals as, on the one hand, they, intuitively, have little potential to be resolved in parallel, and on the other hand, these are the only tasks that are available initially.

One natural approach to circumvent this is to resolve the tasks ordered by the interval size from large to small, layer by layer. That is, we first determine which half each colour is present in by querying colours one at a time. We then determine which quarter each colour is present in two at a time, and so on. That is, in the $i$ th layer we query $2^i$ colours at a time. Using optimal coin-weighing schemes, this can be done in $\mathcal{O}( (n/2^i) \cdot 2^i/\log (2^i) )=\mathcal{O}(n/i)$ queries. Alas, this is too slow as summing this over all layers $i=0, \dots, \log _2 n$ gives a total of $\mathcal{O}(n\log \log n)$ queries. In order to speed this up to $\mathcal{O}(n)$ queries, we need to find a novel take on coin-weighing schemes where intervals of all different sizes are queried together in one big phase, which respects the dependencies between tasks.

In fact, our solution to this problem is surprisingly elegant. We start by performing a procedure we call preprocess. The aim of which is to use $\mathcal{O}(n)$ queries (so far without any information-theoretic speedup) in order to determine the positions of colours sufficiently well so that, after this point, it is possible to query $n^{\Omega (1)}$ colours together. We then perform a procedure we call solve that employs the parallelism unlocked by preprocess to determine the codeword in an additional $\mathcal{O}(n)$ queries. This procedure is recursively constructed in a manner similar to divide and conquer algorithms, and using a technique similar to the coin-weighing scheme by Cantor-Mills [Reference Cantor and Mills1] to achieve the information-theoretic speedup.

Section 5 is then dedicated to the general case where the number of colours k and number of positions n may differ Mastermind. We prove Theorem 1.2. This can be seen as a direct consequence of Theorem 1.1 and applying previous results by Doerr, Doerr, Spöhel, and Thomas [Reference Doerr, Doerr, Spöhel and Thomas4].

3. Signed permutation Mastermind

In the following section, we show how to reduce the traditional form of Mastermind to signed permutation Mastermind, as defined in Section 2.

3.2 Finding pairwise elementwise distinct one queries

We say that a set of queries $f^{(1)}, f^{(2)}, \dots$ are pairwise elementwise distinct if $f^{(s)}_i\neq f^{(t)}_i$ for all $i \in [n]$ and all $s\neq t$ .

The second part of the reduction is to show how codebreaker can transform the problem to the setting where the codeword is a permutation of $[n]$ . It turns out codebreaker can achieve this by first finding $n$ pairwise elementwise distinct queries $f^{(1)}, \dots f^{(n)}$ such that $b_c(f^{(i)})=1$ for all $i$ . This can be done with high probability using $\mathcal{O}(n)$ random queries in the following fashion.

This argument is due to Angelika Steger (from personal communication).

Algorithm 1: Permutation

Lemma 3.2. Algorithm 1 will, with high probability, need at most $\mathcal{O}(n)$ many queries to identify pairwise elementwise distinct query strings $f^{(1)}, \dots, f^{(n)}$ of length $n$ such that $b_c(f^{(i)})=1$ for all $i\in [n]$ .

Proof. The finding of these strings is done by random queries. Let $S^{(1)} = [n]^n$ start out to be the entire space of possible queries. Sample uniform random queries $X$ from $S^{(1)}$ until one of them gives $b(X) = 1$ . Set this query to be $f^{(1)}$ . Now set aside all colours at the corresponding positions and keep querying. That is, $S^{(2)} = [n]\backslash \{f^{(1)}_1\} \times \ldots \times [n]\backslash \{f^{(1)}_n\}$ and sample again random queries $X$ from $S^{(2)}$ until one of them gives $b(X)= 1$ . In this way set aside $f^{(i)}$ which was received by querying randomly from $S^{(i)} = [n]\backslash \{f^{(1)}_1,\ldots,f^{(i-1)}_1\} \times \ldots \times [n]\backslash \{f^{(1)}_n,\ldots,f^{(i-1)}_n\}$ .

We analyse how many queries this takes. The set $S^{(i)}$ has $n-i+1$ many possible colours at every position and also $n-i+1$ many positions at which there is still a correct colour available. So for each position where there still is an available correct colour, there is a chance of $1/(n-i+1)$ that this is guessed correctly in $X$ , independently of every other position. So the probability that $b(X) = 1$ for a random query is

(2) \begin{equation} \mathbb{P}[b(X) = 1] = (n-i+1) \cdot \frac{1}{n-i+1} \left (1 - \frac{1}{n-i+1}\right )^{n-i} \ge e ^{-1}. \end{equation}

Let $Y_t$ be the number of queries it takes to find the $t$ th string to set aside. Then $Y_t$ is geometrically distributed and the total time is the sum of all $Y_t$ , $t\in [n]$ , which is an independent sum of geometrically distributed random variables with success probabilities as in (2), so expected at most $e^{-1}$ . Applying the Chebychev inequality gives us that, w.h.p. we can find $f^{(1)}$ to $f^{(n)}$ with $\mathcal{O}(n)$ many queries.

3.3 Reduction to signed permutation Mastermind

The previous subsections set the stage for the following lemma, which shows the dependency between the signed permutation Mastermind and the black-peg Mastermind Problem. With only $\mathcal{O}(n)$ additional queries that result from Lemma 3.2 it is possible to solve black-peg Mastermind assuming we can solve signed permutation Mastermind with the same number of queries up to a constant factor. We denote by $\textrm{spmm}(n)$ the minimum number of guesses needed by any deterministic strategy to solve signed permutation Mastermind.

Lemma 3.3. Black-peg Mastermind with $n$ colours and slots can be solved in $\mathcal{O}(n + \textrm{spmm}(n))$ guesses with high probability.

Proof. First apply the algorithms from Lemmas 3.1 and 3.2 to obtain the corresponding queries $z$ and $f^{(1)}, \dots, f^{(n)}$ . Given this, run any optimal solution to signed permutation Mastermind. Whenever this solution wants to perform a query $q\in \{-n, \dots, n \}^n$ , we construct queries $q^+, q^- \in [n]^n$ according to

\begin{equation*}q^+_i = \begin {cases} f^{(q_i)}_i &\text { if }q_i\gt 0\\ z_i &\text {otherwise,}\end {cases}\end{equation*}

and

\begin{equation*}q^-_i = \begin {cases} f^{(-q_i)}_i &\text { if }q_i\lt 0\\ z_i &\text {otherwise.}\end {cases}\end{equation*}

We consequently query $b_c(q^+)$ and $b_c(q^-)$ and return the value $b_c(q^+)-b_c(q^-)$ as the answer to query $q$ .

We want to show that the answers given by this procedure are equal to $\hat{b}_{c'}(q)$ for some permutation $c'$ of $[n]$ not depending on $q$ . Let $\varphi \;:\; [n]^n \rightarrow [n]^n$ be the map given by $\varphi (x)_i = f^{(x_i)}_i$ . As $f^{(1)}_i, \dots, f^{(n)}_i$ are all distinct values between $1$ and $n$ , by construction, it follows that $\varphi$ acts as a bijection on each position of the input. In fact, we claim that

(3) \begin{equation} \hat{b}_{\varphi ^{-1}(c)}(q)=b_c(q^+)-b_c(q^-) \qquad \forall q\in \{-n, \dots, n\}^n. \end{equation}

In other words, any signed query $q$ made in this setting will be answered as if the codeword is $c'\;:\!=\;\varphi ^{-1}(c).$ Observe that (3) implies that $c'$ is a permutation as $\hat{b}_{c'}(i\dots i)$ is, by the definition of $\hat{b}_{c'}(\cdot )$ , equal to the number of occurrences of colour $i$ in $c'$ , and by definitions of $b_c(\cdot ), q^+$ and $q-$ equal to $b_c(f^{(i)})-b_c(z)=1-0=1$ , so each colour appears exactly once in $c'$ .

To see that (3) holds, let $q\in \{-n, \dots, n\}^n$ let $q^+, q^-$ be as above, and consider the contributions to $\hat{b}_{c'}(q)$ and $b_c(q^+)-b_c(q^-)$ respectively from the $i$ th position. If $q_i=0$ , then $q^+_i=q^-_i = z_i$ where, by choice of $z$ , $c_i\neq z_i$ , so the contribution to both expressions is $0$ . If $q_i\gt 0$ , then the contribution from the $i$ th position to $\hat{b}_{c'}(q)$ is $1$ if $c'_i = \varphi ^{-1}(c)_i = q_i$ , and $0$ otherwise. Similarly, the contribution to $b_c(q^+)-b_c(q^-)$ is $1$ if $c_i = q^+_i = f^{(q_i)}_i = \varphi (q)_i$ , and $0$ otherwise. One immediately checks because $\varphi$ is a bijection at any position that the two conditions are equivalent. This works analogously if $q_i\lt 0$ .

As the answers given to the signed permutation Mastermind solution are consistent with $\hat{b}_{c'}(q)$ , the solution will terminate by outputting the string $c'$ . We can consequently compute the codeword $c$ to the original game according to $c=\varphi (c')$ .

With high probability, this process uses only $\mathcal{O}(n)$ queries to obtain $z, f^{(1)}, \dots, f^{(n)}$ . Additionally, it uses two times the number of queries used by the signed permutation Mastermind strategy in order to solve the corresponding signed permutation Mastermind instance, which then obtains the codeword for the original game.

4. Proof of Theorem 1.1

With the reduction from the previous section at hand, we may assume that each colour appears in the hidden codeword exactly once. It remains to show that we can determine the position of every colour by using $\mathcal{O}(n)$ signed queries. Before presenting our algorithm, we will first present a token sliding game that will be used to housekeep, at any point while playing signed permutation Mastermind, the information we currently have for each colour.

Note that if $n$ is not a power of two, some vertices will be associated with intervals that go outside $[n]$ . An example of an information tree for $n=8$ is illustrated in Figure 1.

Figure 1. Information Tree for $n= 8$ . Every node corresponds to an interval, here marked in red.

We introduce handy notation for the complete binary tree $T$ . The root of $T$ is denoted by $r$ . For any vertex, we denote by $v_L$ and $v_R$ its left and right child respectively if they exist and if we descend multiple vertices we write $v_{LR}$ for $(v_L)_R$ . Further $T_L$ denotes the induced subtree rooted at $r_L$ , similarly $T_\star$ is the the induced subtree rooted at $r_\star$ for $\star$ being any combination of $R$ and $L$ such that $r_\star$ exists.

For any instance of signed permutation Mastermind, we perform the following token game on the information tree as follows. We initially place $n$ coloured tokens at the root $r$ , one for each possible colour in our Mastermind instance. At any point, we may take a token at position $v$ and slide it to either $v_L$ or $v_R$ , if we can prove that the position of its colour in the hidden codeword lies in the corresponding sub-interval. See Figure 2 for an example.

The simplest way to move a token is by performing a query that equals that colour on, say, the left half of its current position, and zero everywhere else. We call this step querying a token.

We note that any query of this form can only give $0$ or $1$ as output. We will refer to any such queries as zero-one queries.

Figure 2. Example configuration for $n= 8$ . Tokens of colours $1$ through $8$ are at different positions in the information tree and there are four remaining possibilities for the codeword.

4.1 Solving signed permutation Mastermind

We are now ready to present our main strategy to solve signed permutation Mastermind by constructing a sequence of entropy dense queries that allows us to slide all tokens on $T$ from the root to their respective leaves. This will be done in two steps, which we call Preprocess(T) and Solve(T).

As intervals corresponding to vertices close to the root of $T$ are so large, there is initially not much room to include many colours in the same query. Thus the idea of the preprocessing step is to perform $\mathcal{O}(n)$ zero-one queries, in order to move some of the tokens down the left side of the tree.

Algorithm 2: Preprocess(T)

Preprocess(T), see Algorithm 2, takes the tree, queries (Definition 4.3) all colours whose tokens are at the root $r$ and slides the tokens accordingly. Then repeats for the left child of the root $r_L$ . Then we recursively apply the algorithm to the subtrees of the left two grandchildren of the root $T_{LL}$ and $T_{LR}$ . If the tree has a depth of $2$ or less, we skip all the steps on vertices that do not exist.

Proposition 4.4. The Algorithm 2 Preprocess(T) requires at most $3n_T$ zero-one queries and runs in polynomial time.

Proof. Clearly, if the depth of the tree is $\le 2$ this holds, as we make only a single zero-one query. Then the rest follows by induction, if we analyse the number of queries needed we see, at the root $r$ we need to query at most $n_T$ tokens, and at the left child $r_L$ we query at most $n_T/2$ . In the left grandchildren, we recurse. So if $a(n_T)$ is the total number of queries we need for Preprocess(T) for a tree with $n_T$ leafs, then it holds that

\begin{equation*}a(n_T) \le n_T + n_T/2 + a(n_{T_{LL}})+ a(n_{T_{LR}}) = n_T + n_T/2 + a(n_{T}/4)+ a(n_{T}/4)\end{equation*}

From which follows that $a(n_T) \le 3n_T$ . Since we only query tokens all queries we do are zero-one queries and this can be done in polynomial time concluding the proof.

The result of running Preprocess(T) is illustrated in Figure 3. All tokens have either been moved to leaves, or to a vertex of the form $r_R, r_{*R}, r_{**R}, \dots$ where each ‘ $*$ ’ denotes either $LL$ or $LR$ . This we call a preprocessed tree. Another way of viewing this is that a tree $T$ is preprocessed if there are no tokens at $r$ or $r_L$ , and the subtrees $T_{LL}$ and $T_{LR}$ are preprocessed.

Figure 3. Tree preprocessed for n = 32, all black vertices have been emptied, tokens are at red vertices.

Once $T$ is preprocessed we can run the second algorithm Solve(T), see Algorithm 3. This is constructed recursively as follows. First note that when $n_T=1$ or $2$ , then the preprocessing has already put all tokens at leaves, so the problem is already solved. Now suppose we already know how to run Solve(T‘) for all preprocessed trees $T'$ with $n_{T'}\lt n$ , and let $T$ be a preprocessed tree with $n_T=n$ . Observe that preprocessing $T$ means that $T_{LL}$ and $T_{LR}$ are both preprocessed. Hence, we already know procedures Solve(T_LL ) and Solve(T_LR ) that move all tokens in the respective subtrees to leaves by making a sequence of queries whose support are restricted to the first and second quarter of the available positions respectively. Similarly, as the preprocessing has determined all colours that belong in the right half of the codeword, we know how to move all tokens in $T_R$ to leaves by first performing Preprocess(T_R ) and then Solve(T_R ), both of which make queries whose support are restricted to the second half of the available positions.

Algorithm 3: Solve(T)

In order to achieve the information-theoretic speedup of queries, the idea is to perform the queries of Solve(T_LL ), Solve(T_LR ) and Preprocess(T_R ) in parallel. This can be thought of as follows. Codebreaker runs the respective algorithms until each of them attempts to make a query. Instead of actually asking codemaker about these queries, codebreaker simply notes the query and pauses the respective algorithm. This continues until all three have proposed queries. Suppose the queries given are $q^{(1)}, q^{(2)}$ and $s$ respectively. Codebreaker combines these into two queries, determined by Lemma 4.5 explained later, that are asked to codemaker, and given the answers, codebreaker computes $\hat{b}(q^{(1)})$ , $\hat{b}(q^{(2)})$ , and $\hat{b}(s)$ that are then presented to the respective algorithms as if they were given from codemaker as answers to the respective queries, after which the algorithms are allowed to continue. This is repeated until all three algorithms have terminated. (In case one of the algorithms terminates while another still makes queries, we can simply treat the terminated algorithm as if it is making the all zeros query until the other ones finish.) Finally, this leaves $T_{LL}$ and $T_{LR}$ solved and $T_R$ preprocessed. Hence we can solve $T$ by running Solve(T_R ) (without any parallelism).

In order to combine queries as mentioned above, we employ an idea similar to the Cantor-Mills construction (1) for coin-weighing.

Lemma 4.5. Define the support of a query $q$ as the set of indices $i\in [n]$ such that $q_i\neq 0$ . For any three queries $q^{(1)}, q^{(2)}$ , and $s$ with disjoint supports and such that $s$ is a zero-one query, we can determine $\hat{b}(q^{(1)}), \hat{b}(q^{(2)}),$ and $\hat{b}(s)$ by making only two queries.

Proof. We query $w^{(1)} = q^{(1)} + q^{(2)} + s$ and $w^{(2)} = q^{(1)} - q^{(2)}$ , where $+$ and $-$ denote element-wise addition subtraction respectively. Then we can retrieve the answers from just the information of $\hat{b}(w^{(1)})$ and $\hat{b}(w^{(2)})$ . If we combine the queries, $\hat{b}(w^{(2)}) + \hat{b}(w^{(2)})= 2 \hat{b}(q^{(1)}) + \hat{b}(s)$ . So we can retrieve $\hat{b}(s) = \hat{b}(w^{(2)}) + \hat{b}(w^{(2)}) \mod 2$ . And then also the queries, $\hat{b}(q^{(2)}) = ( \hat{b}(w^{(1)}) + \hat{b}(w^{(2)}) - \hat{b}(s))/ 2$ and $\hat{b}(q^{(2)}) = ( \hat{b}(w^{(1)}) - \hat{b}(w^{(2)}) - \hat{b}(s))/ 2$ are recoverable.

Proposition 4.6. Calling Algorithm 3 , Solve() , for a preprocessed tree will move all the tokens to leaves. Moreover, the algorithm will use at most $6n_T$ queries and runs in polynomial time.

Proof. The first statement follows by induction. If $n_T\leq 2$ a preprocessed tree already has all its tokens at leaves, nothing needs to be done. The induction step follows by the correctness of Lemma 4.5.

For the runtime analysis, we also use induction. If the depth $n_T\leq 2$ then clearly the statement holds. If $n_T\gt 2$ the procedure first runs Solve(T_LL ), Solve(T_LR ) and Preprocess(T_R ) in parallel. In each iteration of the main loop, we resolve one query from each of the subprocesses by making two actual queries. This continues until all three processes have terminated, meaning that the number of iterations is the maximum of the number of queries made by the respective subprocesses. After which, we run Solve(T_R ). In total, we get the following recursion where $c(n_T)$ is the total number of queries we must make during Solve(T) and $a(n_T)$ the total number of queries that Preprocess(T) must make in a tree with $n_T$ leaves.

\begin{align*} c(n_T) &\le 2 \cdot \max (c(n_{T_{LL}}), c(n_{T_{LR}}), a(n_{T_{R}} )) + c(n_{T_R})\\ &= 2 \cdot \max (c(n_{T}/4), a(n_{T}/2 )) + c(n_{T}/2) \end{align*}

By Proposition 4.4 we know that $a(n_{T}/2) \le 3n_T/2$ so by induction we get that $c(n_T) \le 6n_T$ . All the operations as well as the computing and decoding of the combined queries in Lemma 4.5 are clearly in polynomial time so this concludes the proof.

Now we have all the tools at hand to prove our main result.

Proof of Theorem 1.1. We have Lemma 3.3 which reduces the problem of solving black-peg Mastermind to solving signed permutation Mastermind. For the new instance of signed permutation Mastermind that results from this, we consider the information tree. We move the tokens of this tree to the leaves by first running the algorithm Preprocess(T) and then applying the algorithm Solve(T) on the preprocessed tree. By Propositions 4.4 and 4.6, this takes at most $9n_T$ signed queries and is done in polynomial time. By Observation 4.2 we have found the hidden codeword of the signed permutation Mastermind, and therefore also the hidden codeword of the black-peg Mastermind game. The transformation can be done in polynomial time and by Lemma 3.3 we need at most $\mathcal{O}(n + 9n_T) = \mathcal{O}(n)$ queries to solve black-peg Mastermind.

5. Playing Mastermind with arbitrarily many colours

We briefly make some remarks on other ranges of $k$ and $n$ for Mastermind. By combining Theorem 1.1 with results of Chvátal [Reference Chvátal3] and Doerr, Doerr, Spöhel, and Thomas [Reference Doerr, Doerr, Spöhel and Thomas4], we determine up to a constant factor the smallest expected number of queries needed to solve black-peg and black-white-peg Mastermind for any $n$ and $k$ .

For any $n$ and $k$ , let $\textrm{bmm}(n, k)$ denote the minimum (over all strategies) worst-case (over all codewords) expected number of guesses to solve Mastermind if only black peg information can be used. Similarly, denote $\textrm{bwmm}(n, k)$ the smallest expected number of queries needed if both black and white peg information can be used. The following relation between black-peg and black-white-peg Mastermind was shown by Doerr, Doerr, Spöhel, and Thomas.

Theorem 5.1 (Theorem 4, [Reference Doerr, Doerr, Spöhel and Thomas4]). For all $k\geq n \geq 1$ ,

\begin{equation*}\textrm {bwmm}(n, k) = \Theta \left ( \textrm {bmm}(n, n) + k/n\right ).\end{equation*}