Payoff Query Complexity

• Payoff query complexity is defined as the minimal number of queries needed to compute or approximate fundamental solution concepts in game-theoretic models.
• It analyzes both deterministic and randomized query bounds across various game classes, including bimatrix, multi-player, and automata-based games.
• The framework informs practical algorithm design in quantitative verification and highlights open challenges in tightening bounds and managing exponentially large structures.

Payoff query complexity characterizes the number of queries to a game's payoff structure (oracle or explicit) required to compute or approximate fundamental solution concepts—such as Nash equilibria, mean-payoff values, or related strategic/quantitative properties. This computational lens is central for algorithmic game theory, zero-sum stochastic games, automata-based quantitative synthesis, and empirical game-theoretic analysis. The paradigm arises whenever the underlying game, automaton, or specification is accessible only through black-box queries, simulation-based evaluation, or requires sublinear access in settings with exponential explicit structure.

1. Formal Definitions and Models

The standard model assumes query access to a function mapping pure strategy profiles (or, in some contexts, partial information such as the outcome of a play, or first-order payoff expectations) to real values or payoff vectors. For matrix games, bimatrix games, and multi-player games, the domain is the Cartesian product of strategy sets. In automata or mean-payoff settings, queries correspond to evaluating the value function (mean-payoff, limsup, automaton expression) under particular runs or cycles.

A payoff query model for a game class $\mathcal{G}$ and solution concept $C$ defines the \emph{payoff query complexity} as the minimal number of queries that any algorithm (possibly randomized, possibly approximate) must make to guarantee computation of a solution in $C$ for any instance in $\mathcal{G}$.

Variants include:

• Oracle model for value iteration: Queries return (possibly approximate) dynamic programming operator evaluations (Allamigeon et al., 2022).
• First-order queries: Response to a mixed strategy is the expected payoff vector for all pure strategies of a player (Hadiji et al., 2023).
• Single-payoff versus all-players queries: Fine granularity in multi-player settings (Goldberg et al., 2014).

2. Deterministic and Randomized Query Bounds for Game and Automata Classes

The query complexity landscape is sharply tuned to the structure of the game or automaton, the sought equilibrium or value concept, and the allowed approximation and randomization:

Bimatrix Games

• Exact Nash: $\Theta(k^2)$ queries for $k \times k$ bimatrix games—full matrix inspection is necessary (Fearnley et al., 2013).
• Approximate Nash: For $\epsilon\geq 1/2$, $O(k)$ queries suffice; for $\epsilon = O(1/\log k)$, lower bounds rise to $\Omega(k \log k)$ (Fearnley et al., 2013). Randomized algorithms can find a $(0.382+\epsilon)$-Nash equilibrium with $O(k\log k/\epsilon^2)$ queries, breaking the deterministic $1/2$ threshold (Fearnley et al., 2013).

General Multi-player Games

• Approximate NE (large games with Lipschitz or small-influence property): In $n$-player games with $\gamma$-Lipschitz payoff maps ($\gamma=1/n$), a fully \emph{uncoupled} algorithm finds an $\epsilon\leq 1/8+o(1)$ NE in $O(\log n)$ payoff queries—a provably tight bound for such classes (Goldberg et al., 2016).
• Lower bounds: For binary-action $n$-player games, any randomized algorithm finding constant-$\epsilon$ NE requires $2^{\Omega(n/\log n)}$ queries (Chen et al., 2015). For well-supported equilibria, the lower bound is $2^{\Omega(n)}$.

Anonymous, Graphical, and Congestion Games

• Anonymous games: Exact equilibrium computation may require $\Omega(n^2)$ queries; efficient approximate NE/PTAS algorithms exist for two-strategy anonymous games using $\tilde{O}(n^{3/2})$ queries (Goldberg et al., 2014).
• Graphical games: For bounded-degree $d$, $O(nk^{d+1})$ queries suffice for learning the payoff function and thereby finding an equilibrium (Fearnley et al., 2013).
• Congestion games: In symmetric DAG network congestion games, $n \cdot m$ (number of players times number of resources) queries suffice—even though the pure-strategy space is exponential (Fearnley et al., 2013).

Correlated Equilibria

• For $n$-player, $m$-action games, randomized approximate CE algorithms require $O(n \log n)$ queries; deterministic or exact CE algorithms provably require $2^{\Omega(n)}$ queries (Hart et al., 2013). Both randomization and approximation are essential for efficiency.

Lipschitz Games and Lower Bounds

• Lipschitz games ($\lambda$-Lipschitz influence): For two-actions, the randomized query complexity for finding an $\epsilon$-approximate pure NE is $\lambda^2 2^{\Omega(n\lambda/\epsilon)}$ (Goldberg et al., 2021). For multi-Lipschitz games (heterogeneous influence), the lower bound parameterizes in $\Lambda = \sum \lambda_i$.
• Deterministic lower bounds: For correlated equilibrium with $\epsilon < (m-1)/m\ \lambda$, query complexity is exponential in $n$ (Goldberg et al., 2021).

Zero-Sum Matrix Games: First-order Query Model

• Exact NE ($\epsilon=0$): At least $K/2-1$ queries for $K \times K$ zero-sum matrices (Hadiji et al., 2023).
• Approximate NE: $O(\log K/\epsilon)$ upper bound using optimistic mirror descent; lower bound is $\tilde{\Omega}(\log(1/(K\epsilon)))$ (polylog gap remains) (Hadiji et al., 2023).

3. Mean-Payoff and Quantitative Automata: Window, Universal Graph, and Value Iteration Approaches

Mean-payoff Automaton Expressions

• The classical decision problems (emptiness, universality, inclusion, equivalence) for mean-payoff automaton expressions are PSPACE-complete (Velner, 2011).
• The key to efficient algorithms is a reduction to the feasibility of linear programs over cycles/multicycles of product automata, enabling computation of value-based queries in polynomial space.

Window Objectives in Quantitative Games

• For mean-payoff/total-payoff objectives, "windowed" variants (e.g., fixed window mean-payoff) allow for efficient query complexity in single-dimension settings: P-complete decision for fixed window size, with polynomial time if window size is polynomial (Chatterjee et al., 2013).
• Multi-dimensional fixed window objectives are EXPTIME-complete; bounded window objectives can be non-primitive recursive hard, elevating effective infeasibility despite finite representations.

Mean-Payoff Games via Universal Graphs/Separating Automata

• The query complexity of mean-payoff games using separating automata/universal graphs hinges on the size of the corresponding universal graph (Fijalkow et al., 2018). For integer weights in $(-N,N)$, complexity is $\Theta(n(nN)^{1-1/n})$; for $k$ distinct weights, $O(n^k)$. There is no quasipolynomial time algorithm in this framework for unrestricted mean-payoff games—contrary to the situation for parity games, where separating automata size can be $n^{O(\log d)}$ for $d$ priorities.

Value Iteration and Oracle Query Complexity

• For stochastic mean-payoff and entropy games, value-iteration algorithms using oracle calls yield universal complexity bounds: the number of oracle queries is $O(R/\operatorname{sep})$, where $R$ is a bias norm metric estimate and $\operatorname{sep}$ is the minimal separation between strategy values (Allamigeon et al., 2022).
• For stochastic mean-payoff games with a fixed number of random positions $s$ (and common denominator $M$), explicit bounds: $O\left(n^2 W M^{2\min\{s, n-1\}}\right)$.

4. Expressibility, Certificates, and Complexity Barriers

In mean-payoff and ergodic games, expressibility of the exact value computation as a formula in the existential theory of the reals is possible; for ergodic games, only existential quantification is needed (Chatterjee et al., 2014). The approximation problem is in FNP, but is at least as hard as simple stochastic games (SSGs), a problem known to be in NP $\cap$ coNP. For "sure ergodic" mean-payoff games, the value problem is square-root sum hard, reflecting deep arithmetic complexity (Chatterjee et al., 2014).

In subgame perfect equilibrium (SPE) threshold problems for mean-payoff games, the problem is NP-complete due to short certificate witnesses involving the negotiation function fixed points and combination of plays/cycles—unlike in many other infinite-duration settings (Brice et al., 2022).

5. Implications, Scope, and Open Directions

Payoff query complexity delineates the inherent hardness of black-box equilibrium computation and quantitative verification, especially when structural succinctness or degree of randomization is limited. Key implications include:

• Sharp phase transitions in query (and thus time) complexity, often driven by equilibrium approximation strength, randomization, and game class structure.
• Tractability for anonymous, graphical, and congestion games is due to succinct representation and modular payoff dependencies; generic games, in contrast, are intractable even for strong approximations.
• Randomized, approximate algorithms are both necessary and nearly optimal for efficient computation of Nash/correlated equilibria in general games.
• Techniques based on separating automata/universal graphs reveal the limits of automata-theoretic approaches, and motivate the search for fundamentally novel algorithmic techniques.

Open lines of inquiry include tightening gaps in first-order and payoff query complexity for zero-sum and general games, understanding the complexity of window/quantitative objectives in broader automata settings, and extending certificate-based NP-completeness results to more intricate solution concepts in infinite games. Further, the explicit parameterization of complexity in terms of game-structural quantities (e.g., Lipschitz constants, hitting times, universal graph dimension) remains an active area for both theoretical refinement and practical algorithm design.