docs/schema.md

Schema

Column-by-column documentation for every table in the Cost-Aware Protocol Routing: Matched Protocol Outcomes dataset.

This document is self-contained: everything you need to read the data is here, and every file it references ships inside the dataset itself. You do not need the paper or the code repository to use these tables.

• Paper: https://arxiv.org/abs/2608.14927
• Code: https://github.com/ChihHsuan-Yang/EMNLP_Cost-Aware-Protocol-Routing
• Machine-readable version of this document: registry/schema.json

Every table is CSV (UTF-8, comma-separated, quoted where needed) except data/probe_inputs.jsonl, which is JSON Lines.

What the dataset is, in one paragraph

The same reasoning problems were each run under four LLM collaboration protocols — Baseline (one direct answer), Single (iterative self-correction), PER (planner-executor-reviewer), and Broadcast (multi-agent deliberation) — and the outcome of every protocol on every problem was recorded. Ten settings are released: five benchmark conditions crossed with two solver models (openai/gpt-oss-120b and google/gemma-4-31B-it), covering 6,803 distinct problems and 15,088 (setting, problem) rows. Alongside the outcomes: two documented split schemes, held-out router predictions, two confidence probes, and the paper's aggregate result tables.

No upstream problem text, gold answers, answer options, or reference solutions are included, for licensing reasons. Tables key on stable identifiers instead; reconstruction.md explains how to attach the text from upstream, and license_audit.md records the evidence behind that decision.

Files at a glance

Path	Rows	Role
data/matched_labels.csv	15,088	label — the flagship table
data/problems.csv	6,803	feature — problem metadata
data/labels_for_scoring.csv	12,928	label
data/probe_inputs.jsonl	12,928	feature — identifier manifest
data/splits/six_setting_splits.csv	12,928	feature
data/splits/primary_omnimath_splits.csv	4,181	feature
data/router/six_setting_test_predictions.csv	5,832	label
data/router/six_setting_metrics.csv	18	aggregate
data/costs/omnimath_per_protocol_costs.csv	4,155	feature — per-problem tokens, one setting only
data/confidence/postanswer_confidence_predictions.csv	12,928	feature — headline probe
data/confidence/primary_omnimath_confidence_predictions.csv	839	feature
data/confidence/six_setting_confidence_metrics.csv	6	aggregate
data/confidence/failure_and_protocol_value_targets.csv	24	aggregate
data/aggregate/*.csv	6-24 each	aggregate — the paper's tables
registry/*.csv, registry/*.json	—	registry

Feature files never contain outcomes; label files do. Keeping them apart is deliberate — see the leakage note under data/problems.csv below and in the dataset card.

Run python validate.py in the release root to check your copy. It needs only the Python standard library and exits nonzero on any problem.

Companion documents (all inside this dataset)

File	What it covers
README.md	the dataset card: overview, quick start, leakage warning, licensing
docs/provenance.md	what the release was built from, verification performed, known discrepancies
docs/license_audit.md	per-benchmark license evidence and the redistribution decision
docs/reconstruction.md	how to attach upstream problem text using the released identifiers
docs/anonymization_report.md	sensitive-content scan and what was stripped
TODO.md	known limitations, including the probe reproducibility limit
docs/confidence_probe_prompt.txt	the post-answer probe's prompt, verbatim
docs/primary_confidence_probe_prompt.txt	the pre-answer probe's prompt, verbatim

Conventions

• problem_id — canonical cross-solver problem identifier. Join on this.
• source_problem_id — the identifier as it appeared in that setting's own run artifacts. Differs between solvers for omnimath2 and labbench; see docs/reconstruction.md.
• setting_id — <benchmark>__<condition>__<run_id>; the unit of analysis. Ten settings are released.
• *_correct — integer 0 or 1. 1 means that protocol's final answer was judged correct on that problem.
• oracle_label — one of baseline_llm, single_agent, per, broadcast, none. See "The oracle" below.
• Rates are proportions unless the column name ends in _pct or _points.
• Confidence intervals are 95% percentile intervals from 2,000 problem-level bootstrap resamples.

The oracle

oracle_label is the first protocol that succeeded, scanned in the fixed cost order Baseline -> Single -> PER -> Broadcast. If all four failed, the label is none.

none is a retrospective oracle/router action (abstain, spend nothing), not a fifth protocol execution. There is no "None protocol." Four protocols were run on every released problem; none records that all four were observed to fail.

The oracle is retrospective: it is computed from the realized outcomes of one execution per protocol. It is not a repeated-sampling expected optimum, and a protocol that failed once here might succeed on a resample. Treat the oracle as an upper bound on what a router could have achieved on these specific executions, not as a ground-truth best action.

Tables

data/matched_labels.csv — flagship, 15,088 rows

One row per (setting, problem). Ten settings.

column	type	notes
setting_id	string	one of 10
benchmark_id	string	omnimath2, jeebench, scibench, labbench
slice_id	string	benchmark condition, e.g. llm_strict
run_id	string	run identifier within the setting
model	string	gpt_oss_120b or gemma_4_31b
model_endpoint	string	openai/gpt-oss-120b or google/gemma-4-31B-it
domain	string	math, science, biology
problem_id	string	canonical
source_problem_id	string	as-run
baseline_correct	int 0/1
single_correct	int 0/1
per_correct	int 0/1
broadcast_correct	int 0/1
oracle_label	enum	5 values, see above
any_protocol_solved	int 0/1	1 iff at least one of the four succeeded

Invariants, all verified (see the validation report): oracle_label == 'none' iff any_protocol_solved == 0; oracle_label is exactly the fixed-order recomputation; (setting_id, problem_id) is unique; no nulls anywhere.

This table contains outcome labels. It is a LABEL file, not a feature file.

data/problems.csv — 6,803 rows

Router-visible metadata only, one row per distinct problem. Contains no gold answers, no correctness, no oracle labels, and no problem text. This is the feature-side table.

column	notes
problem_id, benchmark_id, source_problem_id, legacy_tier_id	identifiers
subset	LAB-Bench subset, or JEEBench subject; empty for OmniMath
source	OmniMath competition source (e.g. cayley); benchmark source elsewhere
difficulty, difficulty_tier	OmniMath only; empty for the other three benchmarks
domain	math, science, biology
primary_split_423	train/dev/test for the primary OmniMath split; empty for other benchmarks

Difficulty metadata exists only for OmniMath. JEEBench, SciBench, and LAB-Bench rows have those columns empty — that is real absence, not a staging omission.

data/labels_for_scoring.csv — 12,928 rows

Labels for the six settings that have router/confidence analyses. Join to data/probe_inputs.jsonl on example_id. Same outcome columns as matched_labels.csv. Kept separate from the inputs file on purpose.

data/probe_inputs.jsonl — 12,928 rows

Feature side of the confidence probe, one JSON object per line. Contains no labels. example_id is the join key.

This file is an identifier and metadata manifest, not a runnable prompt set. It records which examples the probe covered and provides the example_id join key. It does not contain the probe's actual inputs.

The post-answer probe's prompt consumed two things per example: the problem text and the model's own Baseline final answer. Neither is in this release, and neither appears as an empty column — both are absent from the schema.

To build runnable probe inputs you would need to (a) rehydrate the problem text from upstream (see docs/reconstruction.md) and (b) supply that setting's Baseline final answer. Baseline final answers are not released, and for three of the six probe settings they no longer exist in the project's own artifacts either, so the probe is not fully re-runnable by anyone. Coverage is measured and documented in TODO.md.

The probe's outputs are released in full, so the paper's numbers remain reproducible from data/confidence/postanswer_confidence_predictions.csv even though its inputs are not. The prompt template is preserved verbatim in docs/confidence_probe_prompt.txt.

data/splits/six_setting_splits.csv — 12,928 rows

70/15/15, seed 20260712, stratified by oracle label, computed independently per setting. Columns: setting_id, example_id, problem_id, source_problem_id, split, scheme.

Because the split is drawn per setting, a problem can be in train for gpt-oss-120b and test for Gemma-4-31B-it. Measured agreement across solvers is about 54% — roughly what independent draws would give. If you train one model across both solvers' rows, you will leak. The oracle label is deliberately not in this file; get it from data/labels_for_scoring.csv.

data/splits/primary_omnimath_splits.csv — 4,181 rows

80/10/10, seed 42, stratified by oracle label: 3,342 train, 416 dev, 423 test. This is the split behind the paper's 423-problem held-out table. OmniMath only. Columns: benchmark_id, problem_id, legacy_tier_id, split, scheme.

data/router/six_setting_test_predictions.csv — 5,832 rows

Held-out predictions for three routers (metadata_bucket_majority, metadata_logreg, text_metadata_logreg) across six settings. Hyperparameters were selected on dev, then the model was refit on train+dev before the held-out test evaluation. predicted_success is 1 iff the predicted protocol was in fact correct on that problem. Contains labels.

data/router/six_setting_metrics.csv — 18 rows

Per (setting, router) held-out metrics: solve rate with bootstrap CI, baseline and oracle rates, oracle gap, label accuracy, escalation rates.

data/router/six_setting_paired_delta_bootstrap.csv, ..._text_metadata_verification.csv

Paired solve-rate differences versus tier-majority and Baseline, and an independent recomputation of the text+metadata router row. Two avg_tokens cells are nan where per-problem cost accounting was missing for Gemma settings (cost_n / missing_cost_n record the coverage).

data/confidence/six_setting_confidence_metrics.csv — 6 rows

Post-answer, pre-collaboration failure-risk metrics: parse rate, failure AUROC, ECE, Brier, and mean confidence split by outcome, each with a bootstrap CI. The AUROC values are tie-invariant and reproduce exactly; see the AUPRC note below before recomputing any average-precision figure.

data/confidence/failure_and_protocol_value_targets.csv — 24 rows

The same failure score scored against four increasingly protocol-specific targets. This is the paper's central negative result: the score that predicts failure well does not predict which protocol pays off.

AUPRC columns are precise to about two decimals, not four. The probe emits integer confidences, so scores are heavily tied (for example 30 distinct values across 4,151 rows in one setting), and the original average-precision implementation did not handle ties. Recomputing with a standard estimator will not match the published digits; for the worst low-prevalence target the value spans roughly 0.147-0.280 depending on tie ordering, with the published figure inside that range. Every AUROC is tie-invariant and reproduces exactly. Full analysis: docs/provenance/auprc_tie_handling.md in the code repository (https://github.com/ChihHsuan-Yang/EMNLP_Cost-Aware-Protocol-Routing).

data/costs/omnimath_per_protocol_costs.csv — 4,155 rows

Per-problem cost accounting: total tokens and model calls for each of the four protocols. Feature side: no correctness, no oracle label. Join on problem_id.

column	notes
setting_id	always omnimath2__competition_math_4181__gpt_oss_120b
problem_id	canonical, already in this release's normalized id space
baseline_total_tokens, single_total_tokens, per_total_tokens, broadcast_total_tokens	integer token totals
baseline_model_calls, single_model_calls, per_model_calls, broadcast_model_calls	integer counts of model calls

What the token counts are. These are protocol-level totals, summed over every model call the protocol made — which is the paper's cost accounting and the basis of its cost axis. They are not a single call's prompt+completion. The distinction is large, not cosmetic: Baseline averages 9.67 model calls per problem in this setting, so a per-call figure understates protocol cost by roughly that factor. If you compare these numbers against another dataset's total_tokens column, confirm which quantity that column measures before concluding anything.

Coverage: one of ten settings. Only omnimath2__competition_math_4181__gpt_oss_120b has per-problem costs. The other nine settings have no per-problem cost data in this release and must not be assumed comparable; cost for those appears only through the aggregate tables. See TODO.md.

26 of 4,181 problems are omitted. The cost source is indexed by a problem-text key, and 26 problems fall into 13 duplicate-text groups (13 pairs) where the mapping from a cost row to a specific problem_id is not identifiable. Those rows were dropped rather than guessed, so 4,155 of 4,181 problems are covered.

Consequence for the mean, stated rather than smoothed. Mean Baseline tokens over the 4,155 emitted rows is 18,432.0. The paper's published basis, computed over all 4,181 problems, is 18,385.4. The gap is not noise and not a disagreement — it is the arithmetic of dropping 26 identifiable-only-by-guessing rows. Quote 18,385.4 when citing the paper; expect 18,432.0 when recomputing from this file. Do not reconcile them by adjusting either number.

The two confidence probes — do not confuse them

This release ships two different instruments. They ask different questions at different points in the pipeline and they support different numbers in the paper. Every row of both files carries a probe_type column so a reader or a script can never mix them up.

	post-answer	pre-answer
probe_type	post_answer_pre_collaboration	pre_answer_q1
file	data/confidence/postanswer_confidence_predictions.csv	data/confidence/primary_omnimath_confidence_predictions.csv
rows	12,928 (6 settings)	839 (OmniMath primary split only)
when it runs	after Baseline answers, before any collaboration	before any solving
what it sees	the problem, allowed metadata, and the model's own Baseline final answer	the problem only
what it is asked	"is this Baseline answer correct?"	"how likely are you to solve this in one pass?"
supports	the paper's headline failure-risk numbers — data/aggregate/postanswer_confidence.csv and failure_and_protocol_value_targets.csv	the confidence-gate policy row in main_routing_heldout.csv

If you want to reproduce the title claim, use the post-answer file.

data/confidence/postanswer_confidence_predictions.csv — 12,928 rows

The post-answer, pre-collaboration failure-risk probe, all six settings.

Neither probe ever sees the gold answer, the correctness label, the oracle label, or any protocol outcome. The post-answer probe's prompt states that boundary explicitly and is injection-hardened: it labels the problem text and the baseline answer as untrusted data and instructs the model not to follow instructions inside them. The template is shipped verbatim at docs/confidence_probe_prompt.txt.

column	notes
setting_id	one of the 6
problem_id	canonical, normalized — added at staging
example_id	the join key. Setting-scoped, consistent within a run
problem_uid_run	the run's native identifier, for traceability only
probe_type	always post_answer_pre_collaboration
prober_model, run_id	prober identity
parse_ok	boolean; 12,833 of 12,928 parsed cleanly
confidence	integer 0-100, P(the Baseline final answer is correct)
confidence_norm	the same value on 0-1
repair_attempts, parse_error	parse diagnostics

Reproducibility limit. The post-answer probe cannot be fully re-run from released artifacts, because the Baseline final-answer string that the probe consumes was not persisted for the gpt-oss runs. The probe's outputs and metrics are fully released and independently reproducible. Recoverable coverage is 6,462 / 12,928 probe rows (50.0%): 100% for the three Gemma settings, 0% for the three gpt-oss settings. See TODO.md in the release root.

Join on example_id, never on problem_uid_run. The Gemma and gpt-oss runs use different native identifier schemes for the same problems (omni2_1 versus omni2:t01:1; labbench_cloningscenarios_000001 versus lab-bench:CloningScenarios:00540e26-...). A join on the native id against the normalized ids gives zero overlap for all three Gemma settings while the three gpt-oss settings join perfectly — it silently drops half the data and still looks like it worked. registry/example_id_crosswalk.csv maps (setting_id, example_id) -> problem_id so you never have to rediscover this.

The failure score is 1 - confidence_norm against the target baseline_correct == 0, over parse_ok rows only. Computed that way, this file reproduces data/aggregate/postanswer_confidence.csv for all six settings on n_total, n_parseable, parse_rate and failure AUROC, to four decimals — including the headline 4,181 / 4,151 / 0.8847.

data/confidence/primary_omnimath_confidence_predictions.csv — 839 rows

The pre-answer q1 probe on the primary OmniMath split (423 test + 416 dev), prober openai/gpt-oss-120b, temperature 0, prompt version v3_single_pass_prob_only_json. Its template is docs/primary_confidence_probe_prompt.txt. Feature side: carries no correctness and no oracle label. Join via problem_id.

probe_question_id is the probe's question identifier (always q1) — it is not problem text. The column was renamed from question so that neither a reader nor an automated text-leakage scan mistakes it for one.

confidence_probability is on a 0-100 integer scale, not 0-1. Despite the name, observed values run from 7.0 to 99.0 across 41 distinct values. A threshold of 70 means 70 percent. Reading the column as a 0-1 probability and applying >= 0.70 selects nearly every parsed row and silently produces a wrong number that looks plausible — see the worked example below.

Fallback rows carry NO confidence value. status is ok or fallback_after_failure; used_fallback is true for 222 rows (113/423 test, 109/416 dev), where JSON parsing failed after up to three attempts. For every one of those 222 rows confidence_probability is empty — the probe produced no usable number. Exactly 617 rows carry a value. The 0.7329 test coverage rate in the run's own summary is the parsed fraction.

What a consumer should do with the 222 empty rows. The documented confidence-gate policy treats a missing confidence as escalate — no evidence of safety is not evidence of safety. Dropping them, or treating them as "stay", changes the answer. Measured on the 423 test problems, Baseline-or-escalate-to- Single:

reading of the column	test solve rate
0-100 scale, >= 70, empty = escalate	78.01% — matches the published 78.0
0-100 scale, >= 70, empty = stay	73.76% — wrong
misread as a 0-1 probability, >= 0.70	60.76% — wrong

Only the first row reproduces data/aggregate/main_routing_heldout.csv. Do not treat fallback rows as clean measurements, and do not silently drop them.

data/aggregate/*.csv — 8 files

The paper's ancillary aggregate tables, reproduced verbatim from the camera-ready anc/ directory, with a setting_id column added where a (solver, setting) pair maps to one of the ten released settings. main_routing_heldout.csv has no such column: its rows are policies on the primary 423-problem split, not settings. per_broadcast_bootstrap_conditional.csv is an extra 24-row table from the verification pass, not one of the original eight.

Registry

registry/experiments.csv, benchmarks.csv, models.csv, protocols.csv, example_id_crosswalk.csv, schema.json, release_manifest.json, checksums.sha256.

example_id_crosswalk.csv maps (setting_id, example_id) -> problem_id plus the run-native source_problem_id, for all 12,928 probe examples. Use it to join the confidence predictions to data/matched_labels.csv without hitting the identifier-scheme trap described above. checksums.sha256 covers every file in the tree except itself.