Document the confidence scale and null handling; correct the fallback-row statement; note AUPRC tie sensitivity

README.md

@@ -250,6 +250,14 @@ and is injection-hardened — it marks the problem text and the baseline answer
 enumerates what the model does not have. It ships verbatim at
 [`docs/confidence_probe_prompt.txt`](docs/confidence_probe_prompt.txt).
 
+**`confidence` is 0-100, not 0-1**, in both probe files, and the pre-answer file
+leaves it **empty for all 222 fallback rows** rather than filling in a value. The
+documented gate treats an empty confidence as *escalate*. Get either convention
+wrong and you get a plausible, wrong number: on the 423 test problems the correct
+reading reproduces the published **78.0%**, while misreading the scale gives
+60.76% and treating empties as "stay" gives 73.76%. See
+[`docs/schema.md`](docs/schema.md).
+
 **Join the probe predictions on `example_id`, never on `problem_uid_run`.** The
 Gemma and gpt-oss runs use different native identifier schemes for the same
 problems. Joining on the native id gives *zero* overlap for all three Gemma

docs/schema.md

@@ -215,13 +215,25 @@ cells are `nan` where per-problem cost accounting was missing for Gemma settings
 
 ### `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.
+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
@@ -339,12 +351,33 @@ prober `openai/gpt-oss-120b`, temperature 0, prompt version
 problem text. The column was renamed from `question` so that neither a reader nor
 an automated text-leakage scan mistakes it for one.
 
-`status` is `ok` or `fallback_after_failure`; `used_fallback` is true for
-113/423 test and 109/416 dev rows, where JSON parsing failed after up to three
-attempts. Those rows still carry a `confidence_probability`, produced by the
-fallback path rather than a clean parse. The 0.7329 test coverage rate in the
-run's own summary counts only the `ok` rows. Do not treat fallback rows as clean
-measurements.
+**`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

registry/checksums.sha256

@@ -3,7 +3,7 @@
 be06f3a4e4d079f7a34cf319636f88050fca605ca7c3f02c595e36daabd214c4  CITATION.cff
 fe34eb7ac34537c21249e1ff6c9cf7b863eb611f844c0cb212ea358576e32887  LICENSE
 37d5e9d642d6684659d096bd8ebb5ea2de7ccc487fcdb2e4479dfa073c322f23  NOTICE
-21c6b96d7c4aa71df28a5019391eb4a4775c2eda0d3d342d100a3e6838045770  README.md
+32e6270c5c4f3159a464d849a77900aca20cd32bc88bc73696c99b81e249fb5b  README.md
 b90a94d23b3a9d7ad2338acd0cac76aaaea6aaeed6b4cdc85a93dd517cc12d1c  TODO.md
 aad9af7b8ae8cbee7a7d73ecb7393cbb5adcb6ded6d5ec924dc8d1487e34c045  data/aggregate/failure_and_protocol_value_targets.csv
 ff064f045fcfab7e352d58f56070d98c3d1461e6cf44d3dfa0c5b108713c3fa9  data/aggregate/heldout_router_evaluation.csv
@@ -35,12 +35,12 @@ e1b90366deb1815c19748a53c30845c2285d1a20610c647afbf070ff1f2b6543  data/router/si
 4069d4aaf1975279342af805c24b28c9c92617ae85c4e1d3ee6f6f37636e91bc  docs/primary_confidence_probe_prompt.txt
 ed185d33b56a0f86afb2fa120e3cdc13631803d4e0da2f22b2d883204c9e95ea  docs/provenance.md
 abcfeff67504846bd853c573170fa2650761ebc6356b241b1149bffa34417c01  docs/reconstruction.md
-4f09b8708d46a03faf369e3b14d0497bdff3c7519c0fd750ddbe6c26904ac956  docs/schema.md
+869838a59adf5ece35a1a8f0c80e177c38c171321714f0e104c8e4fbaba2b257  docs/schema.md
 964edfed0886c1fc54ef447ed6adf8592b5b42063356bf5a8ba7097f82548798  registry/benchmarks.csv
 0c68fa11540032199e42f3d3802e97885ec7728130c8a30e57870f54899c2130  registry/example_id_crosswalk.csv
 1a97156270d9fcec83019bef45e7ce9f7eaf61befd1cbcc736f6f27800bb2187  registry/experiments.csv
 0b27a71a1bc8ce61efeadec7722cabc566286e5a335cf213fa21b05fcdc4d3c4  registry/models.csv
 e263c1473f08b37726726ee8b7c206f6799fa79e4fd1a128ee121ec3197c8ca5  registry/protocols.csv
 bc320aef5d23bd813da31bcea4345982fc8ae257802be3ee1446796b367f1b9c  registry/release_manifest.json
-4c771f1f38b0d2433b61141be08bf61076524b61baf9e6ac1035d8f9fe73bd25  registry/schema.json
-3b3f133bc05bb42f3afbf3710de78483b33354fc16c54e75200e35f55f2ceb90  validate.py
+3aea6a2d356a1809b69c3e8b0aaf9c54dfe05cbf73d5e2368f06e9f47c90aa70  registry/schema.json
+8e69d6584f3d059969eeb8a6515aa621305f1e223ebd4ffc501731b9f14c20b2  validate.py

registry/schema.json

@@ -1,6 +1,6 @@
 {
   "schema_version": "emnlp-protocol-routing-dataset-v1.0.0",
-  "generated_utc": "2026-09-23T23:53:47.663212+00:00",
+  "generated_utc": "2026-09-24T02:18:59.281412+00:00",
   "conventions": {
     "join_key_cross_solver": "problem_id",
     "join_key_within_setting": "source_problem_id",
@@ -76,7 +76,9 @@
         },
         {
           "name": "auprc",
-          "type": "number"
+          "type": "number",
+          "precision": "approximately 2 decimals, not 4",
+          "caveat": "Scores are heavily tied (integer confidences) and the original average-precision implementation did not handle ties, so a standard estimator will not match the published digits. AUROC is tie-invariant and reproduces exactly. See docs/provenance/auprc_tie_handling.md in the code repository."
         }
       ]
     },
@@ -573,7 +575,9 @@
         },
         {
           "name": "AUPRC_using_failure_score",
-          "type": "number"
+          "type": "number",
+          "precision": "approximately 2 decimals, not 4",
+          "caveat": "Scores are heavily tied (integer confidences) and the original average-precision implementation did not handle ties, so a standard estimator will not match the published digits. AUROC is tie-invariant and reproduces exactly. See docs/provenance/auprc_tie_handling.md in the code repository."
         }
       ]
     },
@@ -618,11 +622,17 @@
         },
         {
           "name": "confidence",
-          "type": "number"
+          "type": "number",
+          "unit": "percent",
+          "scale": "0-100 integer, NOT 0-1",
+          "description": "P(the Baseline final answer is correct), integer percent 0-100."
         },
         {
           "name": "confidence_norm",
-          "type": "number"
+          "type": "number",
+          "unit": "proportion",
+          "scale": "0-1",
+          "description": "The same value as `confidence`, rescaled to 0-1."
         },
         {
           "name": "repair_attempts",
@@ -680,7 +690,16 @@
         },
         {
           "name": "confidence_probability",
-          "type": "number"
+          "type": "number",
+          "unit": "percent",
+          "scale": "0-100 integer, NOT 0-1",
+          "observed_min": 7.0,
+          "observed_max": 99.0,
+          "observed_distinct": 41,
+          "nullable": true,
+          "null_meaning": "the probe produced no parseable confidence (used_fallback=true, status=fallback_after_failure); 222 of 839 rows are null",
+          "null_handling": "the documented confidence gate treats a null as ESCALATE. Threshold 70 means 70 percent. Reading the column as a 0-1 probability, or treating nulls as 'stay', silently yields a wrong solve rate (60.76% and 73.76% respectively, against the published 78.0%).",
+          "description": "P(the model solves this problem in one pass), integer percent 0-100. Empty when unparseable."
         },
         {
           "name": "status",

validate.py

@@ -136,10 +136,17 @@ def abbreviate(items: "list[str]", limit: int = MAX_LISTED_OFFENDERS) -> str:
     return shown
 
 
-def ok(label: str, passed: bool, detail: str = "") -> bool:
-    print(f"  [{'PASS' if passed else 'FAIL'}] {label}" + (f" -- {detail}" if detail else ""))
+def ok(label: str, passed: bool, detail: str = "", fail_detail: str = "") -> bool:
+    """Report one check.
+
+    `detail` is a factual measurement and prints either way. `fail_detail`
+    explains what went wrong and prints ONLY on failure -- a check must never
+    print a reason that contradicts its own verdict.
+    """
+    shown = detail if passed else (fail_detail or detail)
+    print(f"  [{'PASS' if passed else 'FAIL'}] {label}" + (f" -- {shown}" if shown else ""))
     if not passed:
-        FAILS.append(f"{label}: {detail}" if detail else label)
+        FAILS.append(f"{label}: {shown}" if shown else label)
     return passed
 
 
@@ -332,6 +339,34 @@ def main() -> int:
     ok("post-answer example_id is unique", len(set(post_eids)) == len(post_eids),
        f"{len(post_eids) - len(set(post_eids))} duplicates")
 
+    # Scale and null semantics: a "probability"-named column on a 0-100 scale is
+    # the kind of thing a reader gets silently wrong, so assert it rather than
+    # only document it.
+    post_conf = [float(r["confidence"]) for r in post if r["confidence"].strip() != ""]
+    post_hi = max(post_conf) if post_conf else 0.0
+    ok("post-answer `confidence` is on the documented 0-100 scale", post_hi > 1.0,
+       detail=f"range {min(post_conf)}-{post_hi} over {len(post_conf)} parsed rows",
+       fail_detail=f"max is {post_hi}: the column looks like a 0-1 probability, "
+                   f"not the documented 0-100 scale")
+    ok("post-answer `confidence` is blank exactly where parse_ok is false",
+       sum(1 for r in post if r["confidence"].strip() == "")
+       == sum(1 for r in post if r["parse_ok"].strip().lower() == "false"))
+    pre_vals = [float(r["confidence_probability"]) for r in pre
+                if r["confidence_probability"].strip() != ""]
+    pre_hi = max(pre_vals) if pre_vals else 0.0
+    ok("pre-answer `confidence_probability` is on the documented 0-100 scale",
+       pre_hi > 1.0,
+       detail=f"range {min(pre_vals)}-{pre_hi} over {len(pre_vals)} parsed rows",
+       fail_detail=f"max is {pre_hi}: the column looks like a 0-1 probability, "
+                   f"not the documented 0-100 scale")
+    fb = [r for r in pre if r["used_fallback"].strip().lower() == "true"]
+    fb_with_value = sum(1 for r in fb if r["confidence_probability"].strip() != "")
+    ok("pre-answer fallback rows carry NO confidence value (documented as null)",
+       fb_with_value == 0, f"{fb_with_value} of {len(fb)} fallback rows have a value")
+    print(f"  {len(fb)} fallback rows are null; treat a null as ESCALATE "
+          f"(see docs/schema.md -- other readings give 73.76% or 60.76% "
+          f"against the published 78.0%)")
+
     xw = read_csv(os.path.join(root, "registry/example_id_crosswalk.csv"))
     xw_keys = {(r["setting_id"], r["example_id"], r["problem_id"]) for r in xw}
     resolved = sum(1 for r in post