Debate is efficient with your time

Abstract: AI safety via debate uses two competing models to help a human judge verify complex computational tasks. Previous work has established what problems debate can solve in principle, but has not analysed the practical cost of human oversight: how many queries must the judge make to the debate transcript? We introduce Debate Query Complexity}(DQC), the minimum number of bits a verifier must inspect to correctly decide a debate. Surprisingly, we find that PSPACE/poly (the class of problems which debate can efficiently decide) is precisely the class of functions decidable with O(log n) queries. This characterisation shows that debate is remarkably query-efficient: even for highly complex problems, logarithmic oversight suffices. We also establish that functions depending on all their input bits require Omega(log n) queries, and that any function computable by a circuit of size s satisfies DQC(f) <= log(s) + 3. Interestingly, this last result implies that proving DQC lower bounds of log(n) + 6 for languages in P would yield new circuit lower bounds, connecting debate query complexity to central questions in circuit complexity.

• The paper demonstrates that debate protocols enable efficient oversight by reducing the verification of PSPACE/poly functions to a logarithmic number of queries.
• It formalizes Debate Query Complexity (DQC) and connects it to circuit and communication complexity through frameworks like Karchmer-Wigderson games and cross-examination strategies.
• The results imply practical scalability, as even with a million inputs, verification requires roughly 20 queries, highlighting the potential for robust AI alignment.

Efficient Human Oversight in Debate Protocols: A Complexity-Theoretic Perspective

Introduction

The paper "Debate is efficient with your time" (2602.08630) provides a rigorous complexity-theoretic analysis of the debate protocol as a paradigm for AI alignment and oversight. Debate-based AI safety protocols leverage adversarial interaction between two models (provers) and a human (or automated) verifier to amplify human authority in evaluating highly complex computations. The core contribution is the formalisation and study of Debate Query Complexity (DQC)—the minimum number of bits a verifier must inspect in a transcript to decide a computational function $f:\{0,1\}^n \to \{0,1\}$.

The central findings demonstrate that, for problems in $\mathsf{PSPACE/poly}$, human oversight (as measured by queries) scales logarithmically with input size. This establishes that debate protocol oversight is exponentially efficient compared to direct evaluation, and links debate query complexity to circuit and communication complexity via Karchmer-Wigderson and cross-examination games.

Formal Model and DQC Definition

The model centers on a deterministic interactive proof system. Two competing, computationally unbounded provers alternate moves, generating a transcript. A verifier, restricted to querying $\ell$ bits in total (from transcripts and input), adjudicates which prover is correct. The protocol ensures soundness by alternation ($\forall/\exists$) of moves—each prover's strategy must be robust against all possible adversarial responses.

DQC is defined as the smallest $\ell$ for which a valid protocol ensures the verifier can recover the correct value of $f(x)$ for any input $x$, under all possible transcript scenarios. Critically, DQC abstracts out transcript length—focusing solely on the cost to the verifier.

Lower Bounds: Necessity of Logarithmic Oversight

A fundamental result is that any function $f$ depending on all input bits necessarily requires $\Omega(\log n)$ queries. This follows by leveraging Shannon-type arguments: any deterministic $\ell$-query protocol can differentiate at most $2^\ell$ input coordinates. For functions with global dependence, the verifier must in principle distinguish among $n$ bits, hence $\ell \geq \log n$.

Circuit Upper Bounds: Depth and Size-based Compression

The paper generalizes DQC upper bounds via Boolean circuit realizations:

• Depth Bound: By adapting Karchmer-Wigderson games to the debate framework, it is shown that $DQC(f) \leq \text{depth}(C_f)+1$, where $C_f$ is a depth-optimized circuit for $f$. This protocol requires the debaters to traverse circuit layers, with each alternation pinpointing a constituent input or gate.
• Size Bound via Cross-Examination: Using cross-examination strategies, where one prover outputs intermediate computations and the challenger points out a single error, the verifier's query complexity scales logarithmically in circuit size: $DQC(f) \leq \log(\text{size}(C_f))+3$. Notably, this allows for linear-length debates (transcripts) but achieves query efficiency—only $O(\log m)$ queries to validate a computation of size $m$.

These results produce tight upper bounds for a wide range of circuit classes, notably for shallow circuits (AC$^0$, NC$^1$) and also for polynomial-size circuits.

Characterization of $\mathsf{PSPACE/poly}$ via DQC

The main theorem establishes a precise correspondence:

$$\mathsf{PSPACE/poly} = \{f : DQC(f) \leq O(\log n)\}$$

Two proof directions are detailed:

• Any function in $\mathsf{PSPACE/poly}$ can be decided via debates of polynomial length by polynomial-size circuits. By compressing these verifications through cross-examination, only $O(\log n)$ queries to the transcript are required.
• Conversely, functions with logarithmic DQC can be simulated in $\mathsf{PSPACE/poly}$. The verifier's adaptive querying can be encoded in a polynomial-size lookup table as advice. Honest debaters align their transcript outputs to queried locations, maintaining protocol integrity.

This result is strong: it applies even when transcript length or verifier computation is unbounded—it is only the query cost that is bounded logarithmically.

Randomized Verifiers and Robust Lower Bounds

The analysis extends to randomized verifiers, showing that for functions with global dependence (e.g., parity), the randomised query complexity cannot improve beyond logarithmic. The proof employs Yao's principle, constructing distributions over input/transcript pairs to lower bound error rates for bounded-query protocols. The result is $\ell \geq \log n - 3$, confirming that deterministic and randomized verification require similar levels of oversight in debate protocols, at least for $\mathsf{PSPACE/poly}$ functions.

Connections to Circuit Complexity and Implications

A striking implication is the link between DQC and circuit complexity. The size-based upper bound implies that any improvement in DQC lower bounds for explicit functions would yield new circuit lower bounds—surpassing the longstanding $5n$ explicit bound for languages in $\mathsf{P}$. This places DQC within the core landscape of complexity theory, suggesting that query-efficient debate protocols are subject to the same barriers as circuit lower bound proofs.

Moreover, debate protocols connect naturally to communication complexity via Karchmer-Wigderson games. The alternating quantifier structure and the cross-examination paradigm offer information-theoretic reductions of verification overhead, with potential applications in multiparty verification and streaming algorithms.

Practical Implications and Theoretical Outlook

The theoretical efficiency translates directly: for $n=10^6$ inputs, oversight requires around 20 queries, regardless of computational complexity. This supports the claim that scalable human or automated oversight is feasible for verifying complex AI-generated computations, provided debate-style adversarial protocols are used.

The findings also imply that the verification logic (the "judge") can be algorithmically simple (low-depth circuits, look-up tables), further facilitating practical deployment and alignment.

Open Problems and Future Directions

Several avenues remain for both practice and theory:

• Empirical validation: Does LLM-based debate realize these theoretical query efficiencies? How do realistic constraints (bounded computation, unknown verifier structure) affect DQC scaling?
• Circuit lower bounds: Is it possible to leverage DQC frameworks to push explicit circuit lower bounds for $\mathsf{P}$ or $\mathsf{NP}$ languages?
• Multiparty/streaming extension: Can DQC be generalized to more complex adversarial protocols (more provers, partial information)?
• Alignment under opaque verifiers: How does protocol efficiency hold when the judge/verifier is a black-box LLM or an oracle for human values?
• Randomized protocols and advice complexity: Investigate the interplay between randomization, advice, and query costs in practical implementations.

Conclusion

This paper rigorously characterizes the efficiency of oversight in debate-style verification, showing that adversarial protocols reduce oversight to logarithmic queries for highly complex computational tasks. The links forged between DQC and circuit/communication complexity highlight both practical promise and theoretical depth. The debate protocol, thus, provides a scalable foundation for AI alignment and verifiable computation, with rich connections to longstanding open problems in complexity theory.