Debate Query Complexity (DQC) Overview

• Debate Query Complexity (DQC) is defined as the minimal number of bits a deterministic verifier must inspect in debate-style protocols to resolve a computational question.
• It bridges deterministic and non-deterministic query models by varying adversarial input switches and oversight loads, with applications in AI debate and verification.
• Key results show that problems in PSPACE/poly can be verified with O(log n) queries, linking DQC to circuit complexity and robust AI oversight.

Debate Query Complexity (DQC) quantifies the minimal number of bits that a verifier needs to inspect to resolve a computational question using adversarial or debate-based protocols. The concept crystallizes two streams of research: one interpolates between deterministic and non-deterministic query models via adversarial change-bounded debates (Gerbner, 2019); the other investigates the oversight load in AI-debate settings, analyzing how many queries a human judge must pose to the transcript to verify computation outcomes (Brown-Cohen et al., 9 Feb 2026).

1. Foundations and Definitions

Let $f: \{0,1\}^n \to \{0,1\}$ denote a Boolean function. The Debate Query Complexity, denoted $DQC(f)$, is defined as the smallest $\ell$ such that there exists a $(k,\ell)$-debate protocol for $f$ and a deterministic $\ell$-query verifier $M_\ell$ that, with honest provers, guarantees $M_\ell(x,\alpha,\beta) = f(x)$ for all $x$ (Brown-Cohen et al., 9 Feb 2026). Formally,

$$DQC(f) = \min\{\ell : \;\exists \;(k,\ell)\text{-debate with deterministic verifier that outputs }f(x)\}.$$

In foundational adversary models (Gerbner, 2019), for a query problem $DQC(f)$0 on inputs of size $DQC(f)$1, the deterministic query complexity $DQC(f)$2 is the minimum worst-case number of queries needed by an algorithm to determine $DQC(f)$3, while the non-deterministic (certificate) query complexity $DQC(f)$4 is the maximal minimal size of a verification certificate over all inputs.

An interpolating family of complexities, $DQC(f)$5, is defined by bounding the number of times an adversary is permitted to switch (i.e., "cheat") the underlying input during a query process. When $DQC(f)$6, the adversary must commit to its input initially; when $DQC(f)$7, this reduces to standard adversarial (deterministic) query complexity.

2. Debate Models and Query Strategies

A core framework for DQC is the alternating $DQC(f)$8-move debate between Prover 0 and Prover 1, producing a transcript augmented by a verifier inspecting at most $DQC(f)$9 bits. The crucial property is that, no matter the input, the honest prover can always force the correct solution, leveraging the structure of the transcript and the limited adversarial power.

In the game-theoretic setting (Gerbner, 2019), these models interpolate between worst-case and certificate-based query processes by parameterizing the flexibility of the adversary through $\ell$0, the maximum allowable input switches:

• $\ell$1: Adversary can switch inputs arbitrarily;
• $\ell$2: Adversary commits at the start;
• $\ell$3: Adversary may change the input up to $\ell$4 times, always subject to consistency with prior responses.

Formally,

$\ell$5

with $\ell$6 and monotonicity $\ell$7.

3. Characterizations and Main Theorems

A central result is the equivalence between $\ell$8 and the class of Boolean functions with $\ell$9-query debate protocols (Brown-Cohen et al., 9 Feb 2026): $(k,\ell)$0 This asserts that efficient debate-based human oversight (in terms of the number of queries required for verification) extends to all problems solvable with polynomial advice and polynomial space.

On the lower bound side, for any total function $(k,\ell)$1 depending on all $(k,\ell)$2 input bits,

$(k,\ell)$3

This is due to the fact that $(k,\ell)$4 queries can only distinguish between $(k,\ell)$5 settings, so to resolve all $(k,\ell)$6-bit inputs, at least $(k,\ell)$7 queries are necessary.

For upper bounds, any Boolean function computable by a size-$(k,\ell)$8 circuit satisfies

$(k,\ell)$9

via protocols in which one prover supplies the claimed outputs of all gates and the other prover points to one inconsistent gate (if possible), letting the verifier check the relevant circuit path with a logarithmic number of queries.

4. Canonical Problems and Debate Complexity Interpolations

Adversarial-change models yield explicit $f$0 results for classical problems (Gerbner, 2019):

Problem	$f$1	$f$2 interpolation	$f$3 (deterministic)
Single-defective search	$f$4	$f$5	$f$6
Group testing ($f$7)	$f$8	$f$9 for $\ell$0	$\ell$1
Sorting ($\ell$2 items)	$\ell$3	$\ell$4	$\ell$5
Max and min	$\ell$6	$\ell$7	$\ell$8
Graph connectivity	$\ell$9	$M_\ell$0	$M_\ell$1

This table exhibits the linear growth of $M_\ell$2 with $M_\ell$3 for small $M_\ell$4 and its saturation at the deterministic query complexity. For example, in the single-defective search with $M_\ell$5, $M_\ell$6, $M_\ell$7, $M_\ell$8, and $M_\ell$9 for $M_\ell(x,\alpha,\beta) = f(x)$0.

5. Circuit Complexity Connections

DQC provides new perspectives on circuit lower bounds. The circuit-size upper bound, $M_\ell(x,\alpha,\beta) = f(x)$1, implies that if for any $M_\ell(x,\alpha,\beta) = f(x)$2 there exists $M_\ell(x,\alpha,\beta) = f(x)$3 with

$M_\ell(x,\alpha,\beta) = f(x)$4

then $M_\ell(x,\alpha,\beta) = f(x)$5 would require circuits of size at least $M_\ell(x,\alpha,\beta) = f(x)$6. This connection means that meaningful DQC lower bounds for functions in $M_\ell(x,\alpha,\beta) = f(x)$7 or $M_\ell(x,\alpha,\beta) = f(x)$8 would yield significant progress on fundamental open questions in circuit complexity (Brown-Cohen et al., 9 Feb 2026).

6. Interpretations, Extensions, and Open Directions

DQC, and its interpolation generalizations $M_\ell(x,\alpha,\beta) = f(x)$9, offer a fine-grained analysis of adversarial power in query models. The parameter $x$0 in $x$1 is interpreted as the number of "paradigm shifts" or debates—quantifying the robustness of computation under a bounded number of adversarial changes or model invalidations (Gerbner, 2019). This provides a lens for analyzing the overhead incurred when inputs or models may shift during the process, with implications for

• property testing under bounded input flips,
• streaming/adaptive data-structure queries,
• boundedly inconsistent communication protocols,
• randomized or noisy query models with bounded change.

The debate model in the context of AI safety uses $x$2 to formalize the minimum inspection load for a human judge to reliably oversee computations in adversarial settings. The key finding is that, for expressively rich problems ($x$3), logarithmic oversight suffices, supporting the practicality of scalable debate-based human verification mechanisms (Brown-Cohen et al., 9 Feb 2026).

Open questions include achieving tighter $x$4 bounds for complex group testing, geometric, or monotone Boolean functions, and understanding the behavior of $x$5 in randomized and composite adversarial-change settings. Further exploration could yield tools for quantifying model robustness and uncovering deeper connections to computational lower bounds.

7. Historical Context and Research Directions

Debate Query Complexity synthesizes threads from adversarial query complexity and interactive proof models. The "limited-cheating" adversary perspective (Gerbner, 2019) refines the dichotomy between deterministic and non-deterministic queries, enabling a quantifiable spectrum of resilience to adversarial modification. The DQC model in debate-oriented AI oversight (Brown-Cohen et al., 9 Feb 2026) establishes rigorous thresholds for human query cost in scalable, adversarial human-in-the-loop verification.

A plausible implication is that robust AI oversight protocols—and, more abstractly, algorithmic models resilient to bounded adversarial shifts—may universally require only logarithmic query complexity, barring breakthroughs in circuit complexity. This unifies perspectives from property testing, complexity theory, and computational social choice under the umbrella of debate-based query models.