Permutation Mastermind Game

• Permutation Mastermind Game is a deductive puzzle where the codebreaker identifies a secret permutation through feedback on fixed points and other combinatorial cues.
• Adaptive strategies, including cyclic-shift and binary search methods, can reduce query complexity to as low as O(n) or O(n log log n) in certain models.
• Non-adaptive approaches and locality-constrained strategies incur higher query counts, highlighting key trade-offs between optimal algorithms and human-inspired moves.

The Permutation Mastermind Game is a deductive, adversarial reconstruction game in which a codebreaker seeks to identify a hidden permutation (or closely related combinatorial object) through a sequence of queries, each yielding combinatorial feedback such as the number of fixed points. The game's study is central to combinatorics, algorithmic information theory, and black-box optimization, with a mature literature exploring its query complexity, optimal strategies, and connections to broader query and search frameworks.

1. Formal Definitions and Key Variants

At its core, Permutation Mastermind is parameterized by a number of positions $n$, an alphabet of $k$ colors (with the permutation case $k = n$), and a feedback function. The principal settings are:

• Permutation Mastermind: The codemaker selects a secret code $\pi^* \in S_n$, the codebreaker submits queries $\sigma_t \in S_n$, and the feedback is the black-peg count—i.e., $$b(\sigma_t,\pi^*) = |\{i: \sigma_t(i) = \pi^*(i)\}|$$ (Ouali et al., 2013, Berger et al., 2016).
• Feedback Variants:
  • Black-peg only: Only the count of correct positions (fixed points) is revealed.
  • Yes-No Model (AB-Mastermind): The codebreaker is only told whether there is any correct position, not how many (Ouali et al., 2020).
  • Binary Feedback / "Wordle" Model: The indices of correct positions are revealed directly (Hiveley, 30 Jun 2025).
• Adaptivity:
  • Adaptive: Queries can depend on previous feedback.
  • Static/Non-adaptive: The entire set of queries is fixed in advance (Larcher et al., 2021, Doerr et al., 2012).
• Locality-constrained: Strategy restricts each guess to be “close” (e.g., in Hamming distance) to the previous guess (Subercaseaux, 27 Jan 2026).

In each round, the codebreaker’s objective is to minimize the number of queries needed to uniquely determine the secret code, either in the worst case, on average, or probabilistically.

2. Query Complexity: Upper and Lower Bounds

The query complexity of Permutation Mastermind is determined by both problem parameters and feedback richness. Major results include:

• Information-Theoretic Bounds: There are $n!$ possible secrets, so at least $\log_2(n!) = \Theta(n\log n)$ bits are needed (Berger et al., 2016).
• Black-peg, Adaptive (Classical):
  • Berger, Chute, and Stone proved that $f(n,n)\geq n-\log\log n$ for large $n$, where $f(n,n)$ is the minimal deterministic query count (Berger et al., 2016).
  • Historically, $O(n\log n)$ queries suffice via recursive/progressive identification algorithms (Ouali et al., 2013).
• Black-peg, Adaptive (Recent Developments):
  • Doerr et al. improved the adaptive upper bound to $O(n\log\log n)$, leveraging randomized coin-weighing, block partitioning, and efficient elimination to adaptively narrow candidate sets (Doerr et al., 2012).
  • Martinsson developed an $O(n)$ adaptive scheme using recursive 0/1 splitting strategies, matching the information lower bound up to constant factors and proving asymptotic optimality in the model where "blank" (unused) entries are permitted and suitably simulated (Martinsson, 2022).
• Black-peg, Non-Adaptive:
  • Static (non-adaptive) setting requires $\Theta(n\log n)$ queries; the probabilistic method constructs discriminating query sets of size $O(n\log n)$ ensuring unique reconstruction for all secrets (Larcher et al., 2021).
• Other feedback:
  • Yes-no feedback (any match, not the count): requires $\Theta(n\log n)$ queries (Ouali et al., 2020).
• Randomized and Deterministic Complexity:
  • In certain permutation-based variants (notably "HiddenPermutation"/LeadingOnes), deterministic complexity is $\Theta(n\log n)$; randomized strategies achieve $\Theta(n\log\log n)$ by exploiting parallelism and probabilistic set reductions (Afshani et al., 2018).

A summary table of classical (non-localized) query complexities:

Model	Feedback	Adaptive Complexity	Non-Adaptive Complexity
Permutation (classical)	Black-peg	$\Theta(n)$ (Martinsson, 2022) or $O(n\log\log n)$ (Doerr et al., 2012)	$O(n\log n)$ (Larcher et al., 2021)
Permutation (yes-no)	Yes/No	$\Theta(n\log n)$ (Ouali et al., 2020)	$\Theta(n\log n)$
Prefix ("HiddenPermutation")	Prefix match	$\Theta(n\log n)$, randomized: $O(n\log\log n)$ (Afshani et al., 2018)	—

These results highlight that increased feedback richness (e.g., knowing the precise positions vs. simply counts) can dramatically reduce complexity, though regime changes (e.g., adaptivity vs. non-adaptivity, or locality constraints) also impose strict phase transitions in attainable performance.

3. Algorithmic Methodologies and Constructive Strategies

Several algorithmic paradigms dominate the literature:

• Cyclic-Shift Phase and Binary Search: Many optimal or near-optimal algorithms start with a set of $n$ cyclic-shifted queries, ensuring positional coverage (each color visits each position exactly once), followed by a sequence of binary search phases that, using careful combinatorial partitioning, deduce the mapping from positions to colors (Ouali et al., 2013, Doerr et al., 2012, Larcher et al., 2021).
• Divide-and-Conquer (Splitting) Frameworks: The "blank-permitting" adaptive strategy recursively splits the set of positions (or colors), using 0/1 membership queries, running down to $O(n)$ total queries (Martinsson, 2022). Simulation of blanks with genuine permutations introduces only $O(\log n)$ overhead.
• Coin-Weighing/Group Testing Reductions: In advanced adaptive schemes, the codebreaker interprets blocks of positions as "coins" and uses combinatorial group tests to rapidly eliminate possibilities, with the overall process echoing efficient coin-weighing algorithms (Doerr et al., 2012).
• Probabilistic Existence for Non-Adaptive: Existence of discriminating query sets of size $O(n\log n)$ is established via inclusion-exclusion and probabilistic counting to ensure that for any possible secret, its answer vector is unique (Larcher et al., 2021).
• Generating Function Analysis: The cyclic-shift strategy admits analysis via generating functions, associating the number of permutations resolved in $r$ guesses with the coefficients of $f_S(x)$, and linking these to classical permutation statistics (Eulerian numbers, derangements) (Hiveley, 30 Jun 2025).

For the variant where only the existence of any match is signaled ("yes-no"), the adaptive cyclic-shift plus binary-search approach still yields $O(n\log n)$ optimality (Ouali et al., 2020).

4. Locality-Constrained and Human-Inspired Strategies

Recent work focused on what is termed the "price of locality." Here, the codebreaker, inspired by human behavior (e.g., TikTok influencers), restricts each guess to be similar to the previous one (e.g., changing only $k$ positions, "local moves"):

• $\ell_k$-Local and $w_k$-Local Strategies: Strategies where consecutive queries differ in at most $k$ positions, globally ($\ell_k$) or within a window ($w_k$) (Subercaseaux, 27 Jan 2026).
• Complexity Regimes:
  • Adaptive $\ell_k$-local: $$(n^2-3n)/(2k)\leq \text{cost} \leq (n^2\log n)/k(1+o(1))$$—implying asymptotic quadratic behavior for small $k$ (Subercaseaux, 27 Jan 2026).
  • $w_2$-window: Requires $\Theta(n^2)$ queries; the best known "conveyor belt" algorithms use adjacent transpositions to roll every candidate across every slot, observing the increase in matches and learning the secret (Subercaseaux, 27 Jan 2026).
• Complexity Transitions: Imposing strong locality can transform an $O(n\log n)$ reconstruction problem into an $\Omega(n^2)$ one—demonstrating that human-preferred, slow-varying strategies are dramatically suboptimal compared to "chaotic" algorithms.

Furthermore, the original satisfiability problem for local-move strategies is NP-hard for $\ell_3$ but admits randomized polynomial-time algorithms for $\ell_2$ (Subercaseaux, 27 Jan 2026).

5. Mathematical Structures: Derangements, Excedances, Generating Functions

Analysis of permutation Mastermind intricately links with classical permutation enumeration:

• Derangements ($D_n$): Derangements count underlie the probability of receiving zero matches for a random query, and are central to combinatorial recurrences that bound the evolution of the codebreaker's knowledge (Hiveley, 30 Jun 2025).
• Eulerian Numbers ($A(n,k)$): The generating function for the cyclic-shift strategy exhibits coefficients matching Eulerian numbers, linking the distribution of excedances in the symmetric group to the rate at which permutations are resolved in exact guess numbers (Hiveley, 30 Jun 2025).
• Recurrence Relations and Generating Functions: Combinatorial recurrences are used to analyze bucket sizes of remaining candidate secrets after each query, bound worst-case progress, and provide exact averages for key quantities (Berger et al., 2016, Hiveley, 30 Jun 2025).

The relationship between combinatorial statistics (fixed points, excedances, block-zeroing) and the effectiveness of guessing strategies is thus formalized using classical tools from algebraic combinatorics.

6. Connections to Black-Box Optimization and Related Problems

A notable line of research arises from connections to black-box optimization benchmarks:

• Permutation-Based Feedback ("HiddenPermutation"/"LeadingOnes"): The game where the secret is a pair $(z, \pi)$ (binary string and permutation), and feedback is the length of the prefix match under $\pi$ (i.e., the permutation-invariant LeadingOnes function). Here, the query complexity is $\Theta(n\log n)$ deterministically, $\Theta(n\log\log n)$ randomized (Afshani et al., 2018). Randomization yields significant savings via parallel set reductions.
• Mastermind with Large Palettes: As $k$ (number of colors) grows, complexity transitions sharply. For $k = n$, the adaptive complexity is $O(n\log\log n)$. For larger $k$, the improvements vanish, and simple random-guessing can match information-theoretic lower bounds (Doerr et al., 2012).
• General Query Games: The algebraic and combinatorial analysis of Mastermind has been generalized to broad classes of query games, where integer feedback is observed and information-theoretic lower bounds are matched up to constants (Martinsson, 2022).

7. Current Research Directions and Open Problems

The contemporary frontier for Permutation Mastermind includes:

• Cyclic-Shift Strategy Optimality: The Kutin–Smithline cyclic-shift strategy for the explicit "indices-revealed" variant is conjectured to maximize, for each $r$, the coefficient in the generating function $f_S(x)$, and thus to be optimal among all deranged strategies—proven for cubic terms and verified computationally for small $n$ (Hiveley, 30 Jun 2025).
• Closing Complexity Gaps:
  • For classical black-peg feedback, whether $O(n)$ adaptive strategies can be achieved for the strict no-repeats permutation case is open; the currently best proven general bound is $O(n\log\log n)$ (Doerr et al., 2012), though $O(n)$ optimality is established for the blank-permitting model coupled with additional recoding (Martinsson, 2022).
  • For the non-adaptive regime, sharpening constants and removing logarithmic slack remains an active pursuit (Larcher et al., 2021).
• Locality Constraints: Quantifying the price of locality, identifying phase transitions (e.g., $\ell_2$ vs. $\ell_3$), and designing instance-optimal strategies under locality constraints are open (Subercaseaux, 27 Jan 2026).
• Generalized Feedback: Understanding the minimal query complexity for broader feedback classes, hybrid feedback (e.g., partial color information), and the power of partial adaptivity or restricted memory in the codebreaker.
• Algorithmic Implementations and Human Play: Characterizing the gap between theoretically optimal strategies and human-invented heuristics, especially as popularized in online and social contexts.

• "Experimenting with Permutation Wordle" (Hiveley, 30 Jun 2025)
• "The Exact Query Complexity of Yes-No Permutation Mastermind" (Ouali et al., 2020)
• "Improved Approximation Algorithm for the Number of Queries Necessary to Identify a Permutation" (Ouali et al., 2013)
• "Price of Locality in Permutation Mastermind: Are TikTok influencers Chaotic Enough?" (Subercaseaux, 27 Jan 2026)
• "Query Complexity of Mastermind Variants" (Berger et al., 2016)
• "Playing Mastermind with Many Colors" (Doerr et al., 2012)
• "Solving Static Permutation Mastermind using $O(n \log n)$ Queries" (Larcher et al., 2021)
• "The Query Complexity of a Permutation-Based Variant of Mastermind" (Afshani et al., 2018)
• "Optimal schemes for combinatorial query problems with integer feedback" (Martinsson, 2022)

This body of work demonstrates the centrality of permutation Mastermind to combinatorial search, algorithmic learning, and computational information theory, illustrating deep connections between classical problems, modern algorithmics, and practical heuristics.