Adversarial proceduralism

Debate rules that cap the honest side's workload

This approach writes debate protocols in advance so that a dishonest player cannot win merely because it can compute more than an honest one. One design lets the honest side succeed using a manageable number of simulation steps, even when its opponent is allowed exponentially many. Another design addresses the tactic of splitting a question into pieces so obscure that answering them honestly would be intractable. It pairs an arguer with an estimator and keeps the honest player's cost comparable to its opponent's. The approach fixes the rules of the debate, rather than running debates and measuring how well the judge does.

The method (highlighting differences with Adversarial proceduralism)

Scroll the diagram sideways to see all of it.

Use it in codefrom aiag.procedural import RecursiveDebate
from aiag import LM
from aiag.procedural import RecursiveDebate

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
debate = RecursiveDebate(prover=lm, skeptic=lm, judge=lm)  # two levels, three steps each

# The prover splits the claim, the skeptic picks the weakest step, and the judge checks only the last one
out = debate("Our town's new bus line will pay for itself within five years.")
print(out["leaf"], out["verdict"])  # the one claim the judge checked, and its P(true)

pip install aiagEvery method in aiag Library on GitHub

Papers

No method has been built for this approach yet. It rests on the work listed below.

Argued for, not built

Work that argues for this approach or sketches a design for it, without building and testing it.

Scalable AI Safety via Doubly-Efficient Debate

Jonah Brown-Cohen et al., Nov 2023

arXiv:2311.14125ProposalGap

Sets out a new set of debate protocols for verifying the alignment of stochastic AI systems. In these protocols, the honest side can always succeed using a simulation of polynomially many steps, even where the dishonest side is allowed exponentially many simulation steps.

CodeDoublyEfficientDebate
from aiag import LM
from aiag.procedural import DoublyEfficientDebate

# A writes out every step of the computation, B names one, and the verifier reruns only that step
double = lambda cases: 2 * cases
honest = DoublyEfficientDebate.first_error(double)
print(DoublyEfficientDebate.cross_examine([10, 20, 40, 80], double, honest))  # -> True
print(DoublyEfficientDebate.cross_examine([10, 20, 45, 90], double, honest))  # -> False

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
out = DoublyEfficientDebate(lm, lm, lm)("Ten flu cases that double every week reach 80 in three weeks.")
print(out["challenged"], out["verdict"])  # in language: the step the skeptic disputes, and the judge's P(it follows)
  • DoublyEfficientDebateProcedureaiag/procedural/adversarial_proceduralism.py:488 Doubly-efficient debate: one debater writes out the whole computation, the other names a single step it says is wrong, and the verifier checks only that step, so the honest side needs one run of the computation and the judge a constant number of queries; with a stochastic oracle the debaters claim each step's probability and the verifier samples only where a claim is challenged (Brown-Cohen et al., 2023).

pip install aiagEvery method in aiag Library on GitHub

Avoiding Obfuscation with Prover-Estimator Debate

Jonah Brown-Cohen et al., Jun 2025

arXiv:2506.13609ProposalGap

A recursive debate protocol that pairs a prover with an estimator. It addresses the case where a dishonest debater decomposes a problem into subproblems that force an honest opponent to solve something computationally intractable. Under certain stability assumptions, the protocol is shown to let the honest debater win with a strategy whose computational cost is comparable to its opponent's.

CodeProverEstimatorDebate
from aiag import LM
from aiag.procedural import ProverEstimatorDebate

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
debate = ProverEstimatorDebate(prover=lm, estimator=lm, judge=lm)

# The estimator prices each subclaim; the prover bets against bad prices and picks where to recurse
out = debate("Raising the speed limit to 80 mph will cut commutes without raising accident rates.")
print(out["leaf"], out["payoff"])  # the claim the judge settled, and the prover's payoff
  • ProverEstimatorDebateProcedureaiag/procedural/adversarial_proceduralism.py:532 Prover-estimator debate: the prover splits a claim into subclaims, the estimator puts a probability on each rather than calling one false, the prover bets the current estimate is too high or too low and picks the subclaim to recurse on, each bet is paid against outcomes sampled from the estimates, and the judge settles the last bet at a leaf (Brown-Cohen et al., 2025).

pip install aiagEvery method in aiag Library on GitHub