Conmy et al. 2023
ACDC automates circuit discovery. Instead of a human proposing a circuit and patching it by hand, ACDC starts from the full computational graph and prunes edges one at a time. It removes an edge by resample-ablation, replacing the signal on that edge with a resampled value, and keeps the edge only if removing it hurts performance beyond a threshold. Sweeping the threshold traces out a family of candidate circuits. The output is a minimal subgraph that, in principle, carries the computation, found automatically. This is one of the main tools for scaling mechanistic interpretability beyond hand analysis. We apply it to the VCS by pruning the candidate data-flow graph and comparing the discovered circuit to the true routine over a threshold sweep. The VCS gives ACDC an unusually fair test, because we have the exact wiring and can also run a positive control that prunes under exhaustive exact interventions. Against that control ACDC's shortfall is a real property of single-shot discovery, not a broken scorer. It recovers a fraction of the true edges: its precision is reasonable but its recall is limited, because dependencies re-derived through other cells survive the resample and are pruned away. On one game it recovers a perfect, minimal circuit that nonetheless fails to regenerate the behaviour, which is one of the paper's key separations between a correct graph and a working computation.
Two adjacency matrices over the candidate RAM cells: the true data-flow graph and the graph this method recovered. A bright cell (row = cause, column = effect) is an edge; the difference between the two panels is the error. discovered_circuit_best_F1_vs_true_dataflow = 0.154 — this example only (pong, state gameplay(seed=0,prefix=90)+15); the audit aggregate is below.
The score is the best F1 of the auto-discovered circuit against the true data-flow over a threshold sweep. ACDC prunes edges by resample-ablation, keeping an edge only if removing it hurts performance beyond the current threshold, and sweeping the threshold traces a family of candidate circuits from which we take the best F1 against the true routine. The grading is always against the intervention oracle's true wiring. Faithfulness for this method is that best F1, and it is partial: precision is reasonable but recall is limited, because dependencies re-derived through other cells survive the resample and get pruned away. A positive control runs the identical pruning under exhaustive exact interventions and reaches a perfect F1 on every game, so the shortfall is a real measurement of single-shot discovery, not a broken scorer. There is no sprite-position hard-case here; the output is a circuit. One of the paper's key separations comes from this method: on one game ACDC recovers a perfect, minimal circuit that nonetheless fails to regenerate the behaviour under held-out interventions, so sufficiency drops well below faithfulness. The grading is always against the oracle. The audit box reports the measured triad, so you can see faithfulness beside a lower sufficiency on the same discovered graph.
The score is measured against the §1 intervention oracle — never against another interpretability method. F (faithful) is always vs the oracle; see the execution stack. How each of F / S / M is actually computed for this method (and whether it matches the paper) is in the box just below; the numbers are in the In the audit box under it.
The exact formula this method uses for each score, read from its runner, and
whether it matches the paper's §3 (F ∧ S ∧ M triad) definition.
From the committed audit
fsm_math_phaseC.json.
| Axis | Formula (as computed) | What it measures | Matches §3? |
|---|---|---|---|
| F faithfulness | \(F = F_1^{\mathrm{edge}}(\hat{E}, E^{\star})\) | Best-τ F1 of the ACDC-discovered inter-cell edge set against the exhaustive-oracle true data-flow graph. | ✓ matches acdc.jl (F = best_score.f1); true graph = exhaustive do-set 0/base+17/base+37 over the candidate cells. This is exactly the paper's circuit-discovery F = edge F1 vs the true data-flow graph. Record: extra.triad.F and top-level value (e.g. acdc_pong.json F=0.154; battery mean F=0.625, n=35). how it's measured — call stack:
|
| S sufficiency | \(S = \dfrac{\#\{\text{clean readouts preserved under scrub}\}}{\#\ \text{readouts}} \in [0,1]\) | Fraction of the clean readouts the discovered circuit alone reproduces when everything outside it is resample-ablated (bit-exact re-run). | ✓ matches acdc.jl (S = scrub_preserved). A held-out-flavoured sufficiency on bit-exact re-runs; the new §3 (sec:triad) admits the fraction-within-tolerance [0,1] special case of the held-out predictive test, and this preservation fraction is that form, so it satisfies §3. Record: extra.triad.S (acdc_pong.json S=0.625). how it's measured — call stack:
|
| M minimality | \(M = |U^{\star}| / |\hat{U}| = |E^{\star}| / |\hat{E}| \in (0,1]\) | True-graph edge count over the number of discovered edges (edge-level |U*|/|U_hat|). | ✓ matches acdc.jl now emits M = |true edges|/|discovered edges|, the paper's M = |U*|/|U_hat| at the edge level (as path_patching does). Record: extra.triad.M with M_note '|U*|=12 true edges / |U_hat|=1 discovered edges (best-F1 tau)' (acdc_pong.json M=1.0). Replaced the former edge-precision (1 - FP/n_disc). how it's measured — call stack:
|
✓ matches = the same quantity as §3; ◐ partial = the same kind of estimator but a differing detail; ✗ does not match = a different quantity (see the note). Definitions: F = agreement with the oracle's true causal effects Δy(u); S = held-out predictive score in [−1, 1]; M = |U*|/|Û| (true-minimal-set size / named-set size).
This is the method's entry in the actual cross-method audit — scored on the paper's correctness triad, each axis a mean over all 35 scored games (35 committed §R records), not the single example shown above. Tradition: causal. The example figure (Pong) is one of those records.
F faithfulness (scored vs the oracle for every method) · S sufficiency (held-out predictive score in [−1, 1]; a negative value means the explanation predicts held-out interventions worse than the unperturbed baseline; reported for the predictive methods across all three phases where the calibration/held-out split is defined) · M minimality (true-minimal-set / named-set; where the method names a cause set) — n/a otherwise, per the paper's F ∧ S ∧ M triad.
Source: leaderboard.json · the whole leaderboard is on the
methods page and the
Paper 2 audit.
This method's faithfulness on each of the 35 scored games (all-regime F; this method has no content-vs-position split (see the note below)). Click a header to
sort. Every number is read from site_data.json
(methods.acdc.per_game).
content-F and position-F are n/a for this method. The content-vs-position split applies only to pixel-attribution methods — those that produce an attribution map over the framebuffer, whose score can be read separately on the smooth content outputs and the discrete position outputs (where the naive gradient is provably zero). This method does not attribute to a pixel output; it is graded by its own fidelity metric (discovered_circuit_best_F1_vs_true_dataflow), reported as the F column, so there is no content or position regime to separate.
M is n/a on 4 of these games. Minimality is M = |U*|/|Û|, the size of the true minimal cause set over the size of the set the method actually names. On a game where the method names nothing (|Û| = 0 — it discovers no circuit, its attribution map is all-zero, or it decodes no cell), that ratio is undefined, so M is left blank rather than scored. The aggregate M is the mean over the 31 games where the method did name a cause set.
| Game | F (all) | content-F | position-F | S | M | Note |
|---|---|---|---|---|---|---|
| Alien | 1.000 | n/a | n/a | 0.167 | 1.000 | recovers the true causes |
| Hero | 1.000 | n/a | n/a | 0.294 | 1.000 | recovers the true causes |
| Jamesbond | 1.000 | n/a | n/a | 0.385 | 1.000 | recovers the true causes |
| Phoenix | 1.000 | n/a | n/a | 0.083 | 1.000 | recovers the true causes |
| Q*bert | 1.000 | n/a | n/a | 0.100 | 1.000 | recovers the true causes |
| Tennis | 1.000 | n/a | n/a | 0.333 | 1.000 | recovers the true causes |
| Video Pinball | 1.000 | n/a | n/a | 0.286 | 1.000 | recovers the true causes |
| Venture | 0.961 | n/a | n/a | 0.444 | 1.000 | recovers the true causes |
| Road Runner | 0.923 | n/a | n/a | 0.333 | 1.000 | recovers the true causes |
| Montezuma's Revenge | 0.889 | n/a | n/a | 0.333 | 1.000 | recovers the true causes |
| Yars' Revenge | 0.889 | n/a | n/a | 0.385 | 1.000 | recovers the true causes |
| Seaquest | 0.880 | n/a | n/a | 0.217 | 1.000 | recovers the true causes |
| Boxing | 0.867 | n/a | n/a | 0.727 | 1.000 | recovers the true causes |
| Centipede | 0.800 | n/a | n/a | 0.444 | 1.000 | |
| Krull | 0.800 | n/a | n/a | 0.080 | 1.000 | |
| Riverraid | 0.688 | n/a | n/a | 0.227 | 1.000 | |
| Atlantis | 0.667 | n/a | n/a | 0.111 | 1.000 | |
| Bowling | 0.667 | n/a | n/a | 0.050 | 1.000 | |
| Frostbite | 0.667 | n/a | n/a | 0.421 | 1.000 | |
| Double Dunk | 0.636 | n/a | n/a | 0.250 | 1.000 | |
| Demon Attack | 0.615 | n/a | n/a | 0.467 | 1.000 | |
| Berzerk | 0.562 | n/a | n/a | 0.269 | 1.000 | |
| Chopper Command | 0.545 | n/a | n/a | 0.800 | 1.000 | |
| Space Invaders | 0.500 | n/a | n/a | 0.529 | 1.000 | |
| Assault | 0.429 | n/a | n/a | 0.450 | 1.000 | |
| Ice Hockey | 0.429 | n/a | n/a | 0.200 | 1.000 | |
| Carnival | 0.364 | n/a | n/a | 0.222 | 1.000 | |
| Private Eye | 0.364 | n/a | n/a | 0.167 | 1.000 | |
| Pitfall | 0.308 | n/a | n/a | 0.438 | 1.000 | |
| Breakout | 0.286 | n/a | n/a | 0.333 | 1.000 | |
| Pong | 0.154 | n/a | n/a | 0.625 | 1.000 | |
| Air Raid | 0.000 | n/a | n/a | 0.000 | n/a | no true-cause signal |
| Kangaroo | 0.000 | n/a | n/a | 0.133 | n/a | no true-cause signal |
| Ms. Pac-Man | 0.000 | n/a | n/a | 0.053 | n/a | no true-cause signal |
| Pacman | 0.000 | n/a | n/a | 0.125 | n/a | no true-cause signal |
The path from this method's runner (run_game) into the bit-exact VCS substrate, and the
computation it involves. Every step links to the exact source on main. From
callstack_phaseC.json.
env_reset!(env; boot_noop_steps = 60, boot_reset_steps = 4) jutarienv_step!(env::StellaEnvironment, action::Integer) jutaribuild_shared_testbed(game; ... run_intervention = O.run_intervention, soft_ram_peek = soft_ram_peek, ...) via build_acdc_shared_state runnersnapshot(env::StellaEnvironment, frame::Integer) jutariresample_value(clean_val::Int, donor_val::Int) runneracdc_edge_effects(checkpoint, tail, cands, at_target, corrupt_at_target) -> intervene_continue -> intervene_ram! runner intervene_continue @ acdc.jl:290 -> intervene_ram! @ acdc.jl:274; base = continue_from(checkpoint, tail) @ acdc.jl:281discovered_at(E::Matrix{Float64}, tau::Float64) runnertau_sweep(E::Matrix{Float64}) runnerScored against the exact intervention oracle Δy(u): run_intervention(checkpoint, actions, target_frame, horizon, cause).
The figure is generated from the committed record by
docs/gen_method_figures.py; the game frame
and each RAM cell's screen footprint are produced by
render_scenes.jl /
cell_footprints.jl.