# Reading Authority Backwards — artifact bundle (v1)

Reproducibility artifacts for *Reading Authority Backwards: Quantifying the Failure
Modes of Automated Control-Plane Measurement in EVM DeFi.*

This bundle lets a reader recompute every number in the paper and inspect the
held-out evaluation end to end. It contains the resolved per-deployment dataset,
the frozen held-out frame, the sealed baseline and guard-directed predictions, the
final held-out ground-truth labels, the scoring protocol, and two verification
scripts. It does **not** contain the resolver implementation or its development
history; the frozen predictions are the resolvers' outputs, not their source.

Each file is versioned under `v1/`. `SHA256SUMS` lists a SHA-256 for every file;
the held-out frame, sealed predictions, ground truth, scoring protocol, and the
`R_B` adapter are the frozen artifacts whose hashes are fixed in `SHA256SUMS` and
`held-out/sealed/_seal_meta.json`.

## Contents

```
main-frame/
  RESOLVED.json              per-deployment dataset (top-100 census)
  AUTH_MODEL.json            resolved authorization mechanism per deployment
  IMMUTABILITY_FINAL.json    immutability / control-model classification
  MAPPING_AUDIT.json         address-mapping audit
  MAPPING_VERIFIED.json      first-party address verification
  PROXY_AUDIT_FINAL.json     independent proxy-detection audit (RQ1)
  SILENCE_BIAS.json          RQ3 2x2 table and test statistics
  TVL_FUNDREACH.json         fund-reaching / TVL fields
  WALK49.json                independent multi-hop walk of the 49 auto-tiered rows
  reconcile.py               recomputes every headline number and checks it

held-out/
  HOLDOUT_DEPLOYMENTS_CONFIRMED.json   frozen frame, ranks 101-200 (61 protocols, 121 cells; identity and scope only)
  HOLDOUT_GROUND_TRUTH.final.json      final held-out ground truth (121 rows)
  HOLDOUT_SCORING_PROTOCOL.md          frozen scoring protocol
  R_B_adapter.py                       frozen baseline tier adapter (R_B)
  verify_holdout.py                    recomputes the headline held-out numbers and checks them
  HOLDOUT_COMPARISON_RESULTS.json      scored comparison, all dimensions
  HOLDOUT_COMPARISON_PER_DEPLOYMENT.csv  per-deployment scoring decisions
  HOLDOUT_COMPARISON_SUMMARY.md        human-readable summary
  RAW_STATE_MANIFEST.json              pinned block and hash per deployment for the raw on-chain state
  RAW_STATE_README.md                  how the raw state was captured
  sealed/
    baseline_raw.json                  fixed-surface baseline, raw output
    baseline_normalized.json           baseline, normalized to the comparison schema
    guard_directed_raw.json            guard-directed resolver, raw output
    guard_directed_normalized.json     guard-directed, normalized
    _seal_meta.json                    seal metadata (hashes, timestamps)

README.md
SHA256SUMS
```

## Reproduce the main-frame numbers

No network access is required; every figure recomputes from the local files.

```
cd main-frame
python3 reconcile.py
```

Expected final line: `74/74 figures reconcile`. Each check names the paper
location (abstract, section, table) it corresponds to and fails the run if a
statistic no longer matches the dataset.

## Reproduce the held-out numbers

```
cd held-out
python3 verify_holdout.py
```

Expected final line: `26/26 held-out figures reconcile`. The script recomputes the
tier comparison, the paired McNemar counts, the `AUTHORITY_OPAQUE` recall and
precision, dependency coverage, the non-upgradeable and abstention counts, and
confirms that `R_B_adapter.py` reproduces `sealed/baseline_normalized.json` from
`sealed/baseline_raw.json`. It then reports the soft metrics (dependency-category
correctness and terminal-type coverage and correctness), which follow the
text-to-category mapping in `HOLDOUT_SCORING_PROTOCOL.md` and are read from
`HOLDOUT_COMPARISON_RESULTS.json` rather than re-derived.

## Verify integrity

```
shasum -a 256 -c SHA256SUMS
```

The frozen-artifact hashes (`HOLDOUT_DEPLOYMENTS_CONFIRMED.json`, the four files
under `sealed/`, `HOLDOUT_GROUND_TRUTH.final.json`, `HOLDOUT_SCORING_PROTOCOL.md`,
`R_B_adapter.py`) match the values recorded in `SHA256SUMS` and `held-out/sealed/_seal_meta.json`.

## Raw on-chain state

The ground-truth records cite `workspace/…` (adjudication working files) and
`raw_state/…` (the raw pinned on-chain state). Those directories are internal and
are not shipped here: `workspace/` is scratch, and `raw_state/` is roughly 60 MB.
Each ground-truth row is self-contained through its `reasoning_summary`, and
`RAW_STATE_MANIFEST.json` gives the pinned block and a hash for every deployment,
so the exact state can be re-fetched from an archive node and checked. The full
raw-state archive is available on request.

## Scope and provenance

The held-out ground truth is AI primary adjudication with prediction-blinded human
review of a predeclared 37-case subset, not an independent human relabeling of all
121 deployments; `HOLDOUT_SCORING_PROTOCOL.md` and the paper describe this
provenance and its limits. The upgrade-path authority task is the one adjudicated
and scored; the overall fastest fund-reaching tier is not.

These artifacts support reproduction of the paper's measurements and its held-out
evaluation. They do not change any experiment or reported number, do not imply any
validation beyond what the paper claims, and do not publish the resolver
implementation.