# REPRODUCE.md — Step-by-Step Reproduction Guide

This document walks through how to reproduce every numbered table, figure, and
headline claim in the paper. Each entry lists the input file (under `data/`),
the command (under `code/`), the expected output number (with the tolerance
the original claim was registered at), and a wall-time estimate.

> All commands assume you have run `uv sync` once. Invoke scripts either via
> `uv run python code/<package>/<script>.py ...` (preferred) or by activating
> the venv (`source .venv/bin/activate`) and running `python code/...`.
> Repository root is the supplementary directory itself.

> Claim IDs (C1, C18, C31, etc.) match the internal claim register; the IDs
> are referenced in the paper's table captions and Methods section. The full
> mapping is in `CLAIM_TO_FILE_MAP.md`.

## Notes on script invocation

The analysis scripts in `code/stratification/` (`mantel_haenszel.py`,
`cluster_bootstrap.py`, `similarity_buckets.py`) operate on **pre-built JSON
inputs**, not directly on the bundled parquets:

- `mantel_haenszel.py --strata-json strata.json` consumes a JSON list of
  `{class, n_leak, k_leak, n_clean, k_clean}` dicts (one per stratum).
- `cluster_bootstrap.py --records-json records.json` consumes a JSON list of
  `{uid, class, leak, correct}` dicts (one per object).
- `similarity_buckets.py --records records.json` consumes a JSON list of
  `{uid, class, sim, leak, correct}` dicts.

A one-line `pandas` adapter converts the bundled parquets to these JSON
shapes. The conversion snippet is shown alongside each command below.

## Disclosure of Run-B framing (please read before §4 reproduction)

In the original Run-B (shipped here as `data/prune_masks/run_B.npy`), the
length filter `min_lvis_term_len=7` removes short common-noun tokens
(`cat`, `box`, `pen`, ...) from the LVIS vocabulary and is applied against
a narrower Cap3D caption source. As a result, **Run-B prunes only 2.7% of
the 874,402-UID Cap3D pool (23,606 items)** — it is NOT size-matched to
Run-A or Run-C, which both prune ~52%. The paper's §4.2.3 reframes Run-B
as a **per-item-impact probe** rather than a size-matched control: Run-B's
6.15pp LVIS cost on 23,606 items vs Run-C's 5.24pp cost on 455,740 items
implies a 22.66× per-item amplification when pruning targets
LVIS-mentioning captions.

An in-flight follow-on (**Run-B-v2**, `min_lvis_term_len=4` against the
joined `text + blip_caption + msft_caption` source, achieving 55.92%
prune) is being trained on the internal cluster; if it completes before
camera-ready, it will be added to the supplementary as a size-matched
any-LVIS control and the per-item-impact framing will then be
complemented by a matched-volume comparison. The shipped `run_B.npy` is
the original 2.7% mask; see `data/prune_masks/README.md`.

## Conventions for "expected number"

- `+/-X.X pp` is the tolerance: any value within that band of the reported
  number is a successful reproduction. The tolerance accounts for bootstrap
  re-seeding and (for the parquet-derived numbers) potential floating-point
  re-rounding.
- `MH` = Mantel-Haenszel pooled risk difference, Greenland estimator
  (`code/stratification/mantel_haenszel.py`).
- `Cluster bootstrap` = bootstrap resampling at the class level, B=2000
  (`code/stratification/cluster_bootstrap.py`).
- `Per-object bootstrap` = bootstrap resampling at the UID level, B=5000.

## What inputs are bundled vs. externally downloaded

The analysis pipelines need three classes of inputs:

1. **Per-object predictions** (top-K class assignments for each LVIS UID
   under the OpenShape model). Bundled at `data/predictions/`. Sufficient
   to reproduce Table 1, Table 2, and all appendix MH tables.
2. **Per-object stratum flags** (boolean leak vs. clean flags per UID, per
   filter family). Bundled for the NN-proxy stratification at
   `data/predictions/lvis_nn_assignments.parquet`. Own-caption stratum flags
   must be re-derived from Cap3D captions; see "Re-derive own-caption flags"
   below.
3. **Caption corpora** (Cap3D / Sketchfab). Not bundled. Reviewers download
   them from the original repositories (see `CITATIONS.md`).

If you only want to verify the numbers in Tables 2-3 and Section 4.4.3, the
bundled inputs are sufficient. To reproduce Table 1 from scratch you also
need to download Cap3D.

---

## Table 1 — Own-caption stratification (Cap3D V2, headline)

Claims: C1, C2, C3, C4, C5, C6, C7 (sensitivity rows), C8 (self-class MH),
C9 (other-class MH).

### Inputs

- Cap3D captions, downloaded separately as CSV (`uid,caption`) or JSON
  (`{uid: caption}`); see `CITATIONS.md`.
- `data/splits/lvis_eval.json` — 46,205-UID LVIS evaluation set with GT
  class assignment.
- A per-object predictions parquet (`uid,gt_first,pred,correct_first,...`)
  produced either by you running OpenShape inference or by joining
  `data/predictions/lvis_nn_assignments.parquet` (which has `correct_first`)
  to your own top-K.

### Re-derive own-caption flags

```bash
# 1. Build per-UID own-caption leak flags from Cap3D captions.
uv run python code/stratification/own_caption_proxy.py \
    --captions   /path/to/cap3d_new.csv \
    --gt-classes data/splits/lvis_eval.json \
    --output     /tmp/leak_own_cap3d_new.json \
    --summary    /tmp/leak_own_cap3d_new_summary.json
```

### Compute the headline numbers

```bash
# 2a. Build per-object records (uid, class, leak, correct) from the bundled
#     NN-assignments parquet joined with the own-caption flags from step 1.
uv run python - <<'PY'
import json, pandas as pd
flags = json.load(open('/tmp/leak_own_cap3d_new.json'))
df = pd.read_parquet('data/predictions/lvis_nn_assignments.parquet')
recs = [
    {"uid": r.uid, "class": r.gt_first,
     "leak": int(flags.get(r.uid, 0)), "correct": int(r.correct_first)}
    for r in df.itertuples()
]
json.dump(recs, open('/tmp/records_own_v2.json','w'))
# Aggregate to per-class 2x2 strata for the MH script.
from collections import defaultdict
agg = defaultdict(lambda: {"n_leak":0,"k_leak":0,"n_clean":0,"k_clean":0})
for r in recs:
    s = agg[r["class"]]
    if r["leak"]:
        s["n_leak"] += 1; s["k_leak"] += r["correct"]
    else:
        s["n_clean"] += 1; s["k_clean"] += r["correct"]
strata = [{"class":c, **v} for c,v in agg.items()]
json.dump(strata, open('/tmp/strata_own_v2.json','w'))
PY

# 2b. Mantel-Haenszel point estimate (Sato + Greenland CIs).
uv run python code/stratification/mantel_haenszel.py \
    --strata-json /tmp/strata_own_v2.json \
    --min-n       10 \
    --output      /tmp/mh_own_v2.json

# 2c. Cluster-bootstrap CIs for the marginal Δ and the MH pooled RD.
uv run python code/stratification/cluster_bootstrap.py \
    --records-json /tmp/records_own_v2.json \
    --n-iter       2000 \
    --mh-min-n     10 \
    --output       /tmp/cluster_boot_own_v2.json
```

### Expected output

| Claim | Number | Tolerance |
|---|---|---|
| C1 marginal Delta (V2) | +11.824 pp [+10.30, +13.36] | +/-0.1 pp |
| C2 cluster-bootstrap CI | +11.94 pp [+7.82, +15.69] | +/-0.3 pp on CI |
| C3 top1 leaked (n=41,631) | 47.685 % | exact |
| C4 top1 clean (n=4,219) | 35.861 % | exact |
| C5 MH cluster-CI (V2 min_n=10) | +2.01 pp [-1.34, +5.23] | +/-0.4 pp |
| C6 MH per-object CI | -0.527 pp [-2.66, +1.62] | +/-0.3 pp |
| C8 self-class MH | +12.83 pp | +/-0.3 pp |
| C9 other-class MH | -6.01 pp | +/-0.3 pp |

For the filter-family sensitivity sweep (C7: D1-D6 + V1/V4a/V4b), re-run the
`own_caption_proxy.py` step with the matching upstream caption file (each
filter variant is implemented as a different input caption normalization;
re-run step 1 with the alternate captions and repeat step 2). The audit's
per-variant numbers are tabulated in `data/audit/G2_A_statistics.md`.

**Wall-time:** ~3 minutes for step 1 (caption normalization), ~1 minute for
step 2 (per-class MH + cluster bootstrap).

---

## Table 2 — Cross-benchmark NN-caption proxy

Claims: C14-C22 (LVIS), C23-C25 (ScanObjectNN OBJ_ONLY, PB_T50_RS, MN40),
C26 (sanity zero-shot accuracies).

### Inputs (LVIS)

- `data/predictions/lvis_nn_assignments.parquet` — per-UID NN-proxy
  assignment (uid, gt_first, pred, correct_first, nn_uid, nn_sim,
  nn_caption_first200, leak_nn_gt_class). All columns documented in
  `data/predictions/README.md`.

### Command (LVIS)

```bash
# Build the per-object records JSON from the bundled NN parquet.
uv run python - <<'PY'
import json, pandas as pd
df = pd.read_parquet('data/predictions/lvis_nn_assignments.parquet')
recs = [
    {"uid": r.uid, "class": r.gt_first,
     "leak": int(r.leak_nn_gt_class), "correct": int(r.correct_first)}
    for r in df.itertuples()
]
json.dump(recs, open('/tmp/records_nn_lvis.json','w'))
from collections import defaultdict
agg = defaultdict(lambda: {"n_leak":0,"k_leak":0,"n_clean":0,"k_clean":0})
for r in recs:
    s = agg[r["class"]]
    if r["leak"]:
        s["n_leak"] += 1; s["k_leak"] += r["correct"]
    else:
        s["n_clean"] += 1; s["k_clean"] += r["correct"]
strata = [{"class":c, **v} for c,v in agg.items()]
json.dump(strata, open('/tmp/strata_nn_lvis.json','w'))
PY

# Marginal + cluster bootstrap (also reports MH cluster-boot at min_n=10).
uv run python code/stratification/cluster_bootstrap.py \
    --records-json /tmp/records_nn_lvis.json \
    --n-iter       2000 \
    --mh-min-n     10 \
    --output       /tmp/nn_lvis_cluster_boot.json

# MH closed-form (Sato + Greenland) at min_n in {5, 10, 20}.
for N in 5 10 20; do
    uv run python code/stratification/mantel_haenszel.py \
        --strata-json /tmp/strata_nn_lvis.json \
        --min-n       $N \
        --output      /tmp/nn_lvis_mh_n${N}.json
done
```

### Inputs (cross-benchmark)

- ScanObjectNN OBJ_ONLY / PB_T50_RS test splits — download separately (see
  `CITATIONS.md`); produce per-object predictions with OpenShape full
  checkpoint.
- `data/splits/modelnet40_test_split.json` — MN40 test split UID list.
- Per-object predictions parquet (your own, produced by OpenShape) for each
  benchmark.

### Command (cross-benchmark)

Each benchmark uses the same MH pipeline as LVIS, with a per-benchmark
predictions parquet and stratification flags. See
`code/stratification/nn_caption_proxy.py` for the NN-proxy assignment script;
it requires an embedding tensor and the captioned-pool of training UIDs.

### Expected output

| Claim | Number | Tolerance |
|---|---|---|
| C14 overall top-1 LVIS | 46.56 % (21,511 / 46,205) | exact |
| C15 leak rate LVIS | 30.09 % (13,905 / 46,205) | exact |
| C16 top1 leaked LVIS | 79.89 % [79.22, 80.55] | exact |
| C17 top1 clean LVIS | 32.20 % [31.70, 32.72] | exact |
| C18 marginal Delta LVIS | +47.69 pp (per-obj), [+44.15, +50.98] cluster | +/-0.1 pp; +/-0.3 on CI |
| C19 MH(min_n=5) LVIS | +31.43 pp [+29.28, +33.32] | +/-0.3 pp |
| C20 MH(min_n=10) LVIS | +31.45 pp [+29.20, +33.65] | +/-0.3 pp |
| C22 % positive classes | 94.5 % | +/-0.5 pp |
| C23 SO OBJ_ONLY MH | +30.30 pp [+21.88, +38.73] | +/-0.5 pp |
| C24 SO PB_T50_RS MH | +37.62 pp [+32.72, +42.52] | +/-0.5 pp |
| C25 MN40 MH | +10.72 pp [+7.82, +13.63] | +/-0.5 pp |
| C26 zero-shot SO/MN40 | 52.67 / 35.29 / 84.44 % | exact |

**Wall-time:** ~1 minute for LVIS; ~1 minute per cross-benchmark.

---

## Figure 2 — NN-similarity bucket monotonicity

Claims: C27, C28.

### Inputs

- `data/predictions/lvis_nn_assignments.parquet` (contains `nn_sim`,
  `correct_first`, and `leak_nn_gt_class`).

### Command

```bash
# Build the per-object records JSON (includes nn_sim for bucketing).
uv run python - <<'PY'
import json, pandas as pd
df = pd.read_parquet('data/predictions/lvis_nn_assignments.parquet')
recs = [
    {"uid": r.uid, "class": r.gt_first, "sim": float(r.nn_sim),
     "leak": int(r.leak_nn_gt_class), "correct": int(r.correct_first)}
    for r in df.itertuples()
]
json.dump(recs, open('/tmp/records_nn_lvis_sim.json','w'))
PY

uv run python code/stratification/similarity_buckets.py \
    --records      /tmp/records_nn_lvis_sim.json \
    --n-buckets    5 \
    --min-n        5 \
    --cluster-iter 2000 \
    --output       /tmp/sim_buckets.json
```

### Expected output

| Quintile | NN-sim range | MH(min_n=5) |
|---|---|---|
| Q1 | [0.627, 0.875] | +35.66 pp |
| Q2 | (0.875, 0.914] | +30.28 pp |
| Q3 | (0.914, 0.944] | +23.96 pp |
| Q4 | (0.944, 0.973] | +22.06 pp |
| Q5 | (0.973, 1.000] | +20.51 pp |

All five CIs exclude zero. Tolerance +/-0.5 pp on each row, +/-0.005 on each
similarity boundary.

**Wall-time:** ~30 seconds.

---

## Table 3 — Counterfactual retraining results

Claims: C36 (Run-0), C37 (Run-C), C38 (Run-B), C39 (Run-A), C40 (MN40
insulation), C41 (contamination deltas), C42 (52% prune ratio rationale for
Run-A/Run-C), C42b (2.7% prune ratio for Run-B at `min_lvis_term_len=7`),
C43 (63%/37% matched-volume decomposition), C50 (training protocol),
C58 (per-item-impact: Run-B's 22.66× amplification, §4.2.3).

> Re-running the four training jobs is heavy (8x A100, ~22 h each). We
> recommend the **shortcut**: parse the shipped, anonymized training-log
> extracts to re-tabulate Table 3 in seconds.

**Run-B framing** (please read): As disclosed in §4.2.3 and at the top of
this file, Run-B (`min_lvis_term_len=7`) prunes only 2.7% of the corpus
(23,606 items), not 52%. The headline matched-volume decomposition (C43,
"63.3% of the 14.27pp gap from data quality") is computed from
Run-0 → Run-A → Run-C (the two size-matched runs at ~52% prune) and does
not depend on Run-B. Run-B numbers below are used for the per-item-impact
probe (C58).

### Shortcut: re-tabulate Table 3 from shipped logs

**Inputs**

- `data/logs/run_0_training.log`
- `data/logs/run_A_training.log`
- `data/logs/run_B_training.log`
- `data/logs/run_C_training.log`

Each file contains the per-eval-step lines extracted from the training log
(`step N loss=... | Test ObjaverseLVIS: top1_acc=... top3_acc=... top5_acc=...
| Test ModelNet40: top1_acc=...`). Author / path / hostname strings are
scrubbed per `ANONYMIZATION.md`. The eval lines are the same as the training
infrastructure emits, with the inference-time evaluation metrics for both
ObjaverseLVIS and ModelNet40 reported every ~500 steps.

**Command** (one-liner; the eval-parsing logic is in `code/training/`)

```bash
# Best and final ObjaverseLVIS / ModelNet40 top1 across all eval steps in each run
for R in 0 A B C; do
    echo "=== Run-$R ==="
    grep "Test ObjaverseLVIS: top1_acc:" data/logs/run_${R}_training.log \
        | awk -F"top1_acc:" '{print $2}' | awk '{print $1}' \
        | python3 -c "
import sys
vals = [float(x) for x in sys.stdin]
print(f'  LVIS best : {max(vals):.2f}  final: {vals[-1]:.2f}  ({len(vals)} eval steps)')
"
    grep "Test ModelNet40: top1_acc:" data/logs/run_${R}_training.log \
        | awk -F"top1_acc:" '{print $2}' | awk '{print $1}' \
        | python3 -c "
import sys
vals = [float(x) for x in sys.stdin]
print(f'  MN40 best : {max(vals):.2f}  final: {vals[-1]:.2f}  ({len(vals)} eval steps)')
"
done
```

### Expected output

| Run | LVIS top-1 (best) | LVIS top-1 (final) | MN40 top-1 (best) | Prune % | Source claim |
|---|---|---|---|---|---|
| Run-0 (baseline) | 50.67 | 50.40 | 86.75 | 0% | C36, C40 |
| Run-C (random, size-matched) | 45.43 | 45.29 | 85.74 | 52.05% | C37, C40, C42 |
| Run-B (any-LVIS, NOT size-matched) | 44.52 | 44.05 | 86.55 | 2.70% | C38, C40, C42b |
| Run-A (self-class, size-matched) | 36.40 | 35.15 | 80.67 | 52.05% | C39, C40, C42 |

Tolerance: +/-0.05 (any reproduction within 0.05 pp counts; the logs are the
raw source of truth).

Derived **matched-volume** deltas (C41), computed from the best-LVIS column
of the two size-matched runs (Run-A and Run-C, both at ~52% prune):

- Delta_data (Run-0 to Run-C) = 5.24 pp (~52% random prune)
- Delta_selfclass (Run-C to Run-A) = 9.03 pp (~52% any-class-name prune,
  matched volume)
- Delta_full_drop (Run-0 to Run-A) = 14.27 pp
- **C43: contamination explains 63.3% (9.03 / 14.27); data quantity 36.7%**

Run-B-involving differences (Delta_anyLVIS = Run-C to Run-B = 0.91 pp;
Delta_selfclass_nested = Run-B to Run-A = 8.12 pp) compare runs **at
different prune ratios** (52.05% vs 2.70%) and are NOT directly
interpretable as a fixed-volume effect. The paper's §4.2.3 re-uses them
as a **per-item-impact** probe instead:

| Probe | Pruned items | LVIS cost | per 1k items |
|---|---:|---:|---:|
| Run-C (random, 52.05%) | 455,115 | 5.24 pp | 0.01150 |
| Run-B (any-LVIS, 2.70%) | 23,606 | 6.15 pp | 0.26053 |
| **Ratio (C58)** | — | — | **22.66x** |

MN40 sanity: Run-B costs only -0.20 pp on MN40, confirming the
amplification is LVIS-vocabulary specific rather than generic
data-heterogeneity.

**Wall-time:** < 5 seconds.

### Verifying the prune masks

```bash
uv run python3 -c "
import numpy as np
for r in ['0', 'A', 'B', 'C']:
    m = np.load(f'data/prune_masks/run_{r}.npy')
    print(f'run_{r}: kept={m.sum():>7d} / {len(m):>7d} ({m.sum()/len(m)*100:.2f}%)')
"
```

Expected:
```
run_0: kept= 874402 /  874402 (100.00%)
run_A: kept= 419287 /  874402 ( 47.95%)   # 52.05% pruned -- C42 (self-class, size-matched)
run_B: kept= 850796 /  874402 ( 97.30%)   # 2.70% pruned -- C42b (any-LVIS at min_lvis_term_len=7; NOT size-matched)
run_C: kept= 419287 /  874402 ( 47.95%)   # 52.05% pruned -- size-matched random control to Run-A
```

Note: The Run-B "any-LVIS" prune ratio is much lower than Run-A/Run-C
because `min_lvis_term_len=7` removes short common-noun tokens (`cat`,
`box`, `pen`, etc.) from the LVIS vocabulary, leaving only ~1,000 long
LVIS class strings to match against; with this filter applied to the
original Cap3D caption source, relatively few captions contain any
remaining LVIS string. The paper's §4.2 acknowledges this and reframes
Run-B as a per-item-impact probe rather than a size-matched comparison;
see `data/prune_masks/README.md` for the full rationale and §4.2.3 of
the paper for the per-item-impact framing. A size-matched any-LVIS
follow-on (**Run-B-v2** at `min_lvis_term_len=4` against a wider caption
source, achieving 55.92% prune) is being trained on the internal cluster
and will be added to the camera-ready supplementary if it completes.
Run-C remains the size-matched random control for Run-A (matched on
keep-count) and isolates "what we pruned" from "how much we pruned".

### Full retraining

If you instead want to re-run all four counterfactual training jobs from
scratch (8x A100 each, ~22 h per run), see `code/training/openshape_pointbert.py`
and `configs/`. Inputs: Cap3D corpus + Objaverse renderings + the four prune
masks in `data/prune_masks/`. Note that the original runs used a bare-metal
DDP setup on 8 GPUs; running on a Kubernetes-scheduled job or with a
different scheduler will produce equivalent numbers but differ on wall-time.

### Cross-stack replication (Tracks T1 bare-metal + T2-MLP Ray cluster) — also shipped

Two of the four counterfactual runs (Run-A and Run-0) were retrained to
completion on two further independent stacks: Track 1 (a second
independent bare-metal stack — distinct hardware/scheduler from the Track 3
numbers above) and Track 2-MLP (a Ray-scheduled MLP cluster — distinct
orchestrator). All stacks share optimizer, step count, and prune masks.
The scrubbed logs are shipped at:

- `data/logs/run_A_T1_training.log` — best LVIS 36.66, final 35.65 (C60)
- `data/logs/run_0_T1_training.log` — best LVIS 49.12, final 48.80 (C61)
- `data/logs/run_A_T2-MLP_training.log` — best LVIS 35.02 (C64); T2-MLP RayJob stopped manually at ~step 30,000 (train-loop overshoot; best reached well before)
- `data/logs/run_0_T2-MLP_training.log` — best LVIS 51.74 (C65); same overshoot/manual-stop pattern

Reproduce best / final LVIS from the shipped T1 and T2-MLP logs the same way
as the T3 logs above:

```bash
for R in 0 A; do
    for STACK in T1 T2-MLP; do
        echo "=== Run-$R ($STACK) ==="
        grep "Test ObjaverseLVIS: top1_acc:" data/logs/run_${R}_${STACK}_training.log \
            | awk -F"top1_acc:" '{print $2}' | awk '{print $1}' \
            | python3 -c "
import sys
vals = [float(x) for x in sys.stdin]
print(f'  LVIS best : {max(vals):.2f}  final: {vals[-1]:.2f}  ({len(vals)} eval steps)')
"
    done
done
```

Expected:

| Run | T3 best | T1 best | T2-MLP best | 3-stack mean | Spread | Source claim |
|---|---|---|---|---|---|---|
| Run-A | 36.40 | 36.66 | 35.02 | 36.03 | 1.64 pp | C64, C66 |
| Run-0 | 50.67 | 49.12 | 51.74 | 50.51 | 2.62 pp | C65, C67 |

Derived cross-stack quantities (C68):

- Three-stack mean Delta_total = 50.51 - 36.03 = 14.48 pp (vs T3's 14.27, T1's 12.46)
- Delta_data anchor is the two-stack Run-C mean (T1 = 45.43, T2-MLP = 45.97; mean = 45.70):
  - Delta_data = 50.51 - 45.70 = 4.81 pp (Run-0 three-stack mean vs two-stack Run-C mean)
- Three-stack contamination fraction = (14.48 - 4.81) / 14.48 = 66.8% (numerator fully three-stack; anchor two-stack T1 + T2-MLP — aligned with paper §4.4 and §5.3)

Run-NN (causal NN-axis intervention) is two-stack complete at submission:
- T1 best LVIS = **40.92** (C69; natural completion to 30K steps)
- T2-MLP best LVIS = **41.09** (C70; best reached at step ~13,566; RayJob manually stopped at ~step 26,334 after train-loop overshoot, same methodology as Run-A/Run-0 T2-MLP)
- Two-stack mean = **41.005** (C71); two-stack Δ_total = 50.51 − 41.005 = **9.51 pp** (C72)

Run-B-v2 (size-matched any-LVIS-token prune at min_lvis_term_len=4, ~56%
prune; T2-MLP only) is also complete:
- Best LVIS = **28.98** at step 12,532 (C73); Δ_total = 50.51 − 28.98 = **21.53 pp** (C74)
- Run-B-v2 was manually stopped after the train-loop overshot 30K (same
  methodology as Run-A/Run-0 T2-MLP); best was reached well before overshoot.

The training logs for Run-NN T1, Run-NN T2-MLP, and Run-B-v2 T2-MLP will
ship in the next supplementary ZIP rebuild as
`data/logs/run_NN_T1_training.log`, `data/logs/run_NN_T2-MLP_training.log`,
and `data/logs/run_B-v2_T2-MLP_training.log` respectively.

---

## Figure 3 — Retraining 4-bar chart

This is the visual presentation of the four numbers in Table 3 (LVIS column).
Use the shortcut above to regenerate the underlying numbers; the bar chart
is then a simple `matplotlib.pyplot.bar` over the four best LVIS top-1
values (50.67, 44.52, 45.43, 36.40). The Figure 3 caption notes Run-B's
2.7% prune asymmetry (vs Run-A/Run-C at 52%); the per-item-impact
arithmetic is in §4.2.3, not in the bar chart itself.

---

## Figure 1 (cover figure)

The cover figure illustrates the two axes of contamination on hand-picked
representative examples. The figure source is a manually arranged composite
and is not bundled. The supporting per-UID data is in
`data/predictions/lvis_nn_assignments.parquet` — filter by the example UIDs
listed in the figure caption to reproduce the per-object top-1 score
annotated on the figure. (Top-3/top-5 per-object scores are not in the
bundled per-object parquet; per-run top-3/top-5 aggregates are available
in `data/logs/run_*_training.log` via the same grep one-liner above with
`top3_acc`/`top5_acc`.)

---

## Section 4.4.3 — Uni3D +/- LVIS reproduced gap (C29, C30, C31)

### Bundled inputs

- `data/predictions/uni3d_per_object_preds.parquet` — per-UID Uni3D
  predictions for both the no-LVIS and with-LVIS checkpoints (92,410 rows =
  46,205 UIDs x 2 variants). Bundled.
- `data/predictions/uni3d_gap_decomp.json` — precomputed decomposition
  numbers (used as a verification reference).
- `data/predictions/lvis_nn_assignments.parquet` — NN-proxy stratum flags.

### Compute the headline numbers

```bash
# 1. The bundled parquet combines both Uni3D variants (`run` column =
#    "no_lvis" | "with_lvis"). Split into two per-variant JSON lists so
#    the decompose script (which expects two files) can consume them.
uv run python - <<'PY'
import json, pandas as pd
df = pd.read_parquet('data/predictions/uni3d_per_object_preds.parquet')
for variant in ['no_lvis', 'with_lvis']:
    sub = df[df['run'] == variant]
    recs = [{"uid": r.uid, "correct_top1": int(r.correct_first)}
            for r in sub.itertuples()]
    json.dump(recs, open(f'/tmp/uni3d_preds_{variant}.json', 'w'))
    print(f'{variant}: n={len(recs)} top1={sum(r["correct_top1"] for r in recs) / len(recs) * 100:.2f}%')
PY

# 2. Decompose the +8.16 pp gap by our NN-proxy leak axis (cluster-bootstrap CI).
uv run python - <<'PY'
import json, pandas as pd
nn = pd.read_parquet('data/predictions/lvis_nn_assignments.parquet')
leak  = {r.uid: int(r.leak_nn_gt_class) for r in nn.itertuples()}
gts   = {r.uid: r.gt_first              for r in nn.itertuples()}
json.dump(leak, open('/tmp/leak_nn.json','w'))
json.dump(gts,  open('/tmp/gts_nn.json','w'))
PY

uv run python code/uni3d_replication/decompose_uni3d_gap.py \
    --preds-no-lvis    /tmp/uni3d_preds_no_lvis.json \
    --preds-with-lvis  /tmp/uni3d_preds_with_lvis.json \
    --leak-flags       /tmp/leak_nn.json \
    --gt-classes       /tmp/gts_nn.json \
    --cluster-iter     2000 \
    --output           /tmp/uni3d_decomposition.json

# 3. Diff against the bundled precomputed sidecar.
diff <(jq -S . /tmp/uni3d_decomposition.json) \
     <(jq -S . data/predictions/uni3d_gap_decomp.json)
```

(`code/uni3d_replication/replicate_uni3d_lvis_gap.py` requires the upstream
Uni3D checkpoints + raw point-cloud data root + class-embedding tensor; it
re-runs the published Uni3D inference end-to-end. The bundled parquet is
its output. To recover only the two headline 47.19 / 55.35 percentages,
the snippet in step 1 above suffices — no Uni3D download required.)

### Expected output

| Claim | Number | Tolerance |
|---|---|---|
| C29 Uni3D no-LVIS top-1 | 47.19 % (21,802 / 46,205) | exact |
| C30 Uni3D with-LVIS top-1 | 55.35 % (25,573 / 46,205) | exact |
| C31 reproduced gap | +8.16 pp | exact |
| C32 Delta_leak +4.29; Delta_clean +9.83; (leak - clean) = -5.54 [-6.98, -4.00] | per-stratum decomposition | +/-0.05 pp |
| C33 fraction of gap in leak stratum | 15.80 % | +/-0.5 % |
| C34 Uni3D no-LVIS MH | +30.84 pp [+28.52, +32.76] | +/-0.3 pp |
| C35 Uni3D with-LVIS MH | +22.53 pp [+21.03, +25.24] | +/-0.3 pp |

C29-C33 are produced directly by the two steps above against the bundled
parquet. C34/C35 require running `mantel_haenszel.py` against per-variant
strata built from `uni3d_preds_{no_lvis,with_lvis}.json` joined with the
NN leak flags + per-class aggregation (same parquet-to-strata adapter
pattern as Table 2 above); the canonical reference numbers are tabulated
in `data/audit/G5_uni3d_replication_v2.md`.

### To re-run Uni3D inference from raw checkpoints

The bundled parquet was produced by running the published Uni3D inference
pipeline on the 46,205 LVIS UIDs for both checkpoints. If you want to
re-derive the parquet yourself, see `code/uni3d_replication/README.md`
for the upstream weight download and the three gotchas (prompt ensemble,
class-name normalization, dtype) that the audit's v1 attempt got wrong.
Hardware: 1x A100 (40 GB). Wall-time: ~30 minutes per checkpoint.

**Wall-time** (analysis-only, against the bundled parquet): ~1 minute.

---

## Appendix A1 — Per-class own-caption MH

**Inputs**

- Re-derived own-caption flags from Cap3D (see Table 1 step 1).
- `data/predictions/lvis_nn_assignments.parquet` (for `correct_first`).

**Command**

```bash
# Build the per-class strata JSON from the own-caption flags (same adapter
# as Table 1 step 2a). Then call mantel_haenszel.py with --min-n 10; the
# script emits per-class point estimates and CIs as JSON. Compare against
# the bundled markdown table.
uv run python code/stratification/mantel_haenszel.py \
    --strata-json /tmp/strata_own_v2.json \
    --min-n       10 \
    --output      /tmp/own_caption_per_class.json
```

The bundled reference table is `data/audit/G2_A_statistics.md`. Diff your
output against this file; rows should match up to bootstrap re-seeding
(~0.1 pp on per-class CIs).

---

## Bundled audit appendix tables

The following per-class / per-bucket markdown tables are bundled under
`data/audit/` so reviewers can read them directly without re-running any
script. They are the authoritative source for the appendix tables
referenced in the paper:

| File | Supports | Description |
|---|---|---|
| `data/audit/G2_A_statistics.md` | App A1 | Per-class MH for own-caption proxy (Table 1 extension) |
| `data/audit/G2_B_statistics.md` | App A2 | Per-class MH on Sketchfab corpus |
| `data/audit/G2_C_eligibility_adjudication.md` | App | MH stratum-eligibility methodology |
| `data/audit/G4_C_captioner_sweep.md` | App A3 | Cross-corpus captioner sweep tables |
| `data/audit/G4_D_sim_buckets.md` | App A4 | Per-quintile sim-bucket breakdown |
| `data/audit/G4_cross_benchmark.md` | App A5 | NN-proxy on MN40 and ScanObjectNN |
| `data/audit/G5_uni3d_replication_v2.md` | App A6 | Uni3D +/-LVIS replication + decomposition |
| `data/audit/G6_captioner_sweep_own.md` | App | Second captioner sweep |
| `data/audit/G0_FINAL.md` | provenance | SHA-256 of upstream artifacts |
| `data/audit/VERDICT.md` | overview | Internal audit verdict (GREEN); reviewer context |

The numeric content of each appendix table is reproducible from the bundled
parquets via the scripts above; the markdown files are the human-readable
reference that came out of the original audit pass.

---

## Appendix A2 — Sketchfab per-class MH

Same as A1 but with the Sketchfab name+description captioner. Reviewers
download the Objaverse metadata (which carries `sf_name_desc` and
`sf_tags` per UID) and pass it as `--captions ...` to the own-caption proxy
script. Reference: `data/audit/G2_B_statistics.md`.

---

## Appendix A3 — Captioner-corpus sweep

### Two distinct sweeps

Paper Table 1 (rows 2-4) reports the **own-caption** captioner sweep (C12,
C13): for each of the four caption corpora, the per-UID own-caption leak
flag is set when the object's own caption (under that corpus) contains its
GT LVIS class string. Reproducing those rows requires staging the four
external caption corpora; we do not redistribute them. The reproducible
aggregates (marginal Δ and MH per corpus) are captured in
`data/audit/G6_captioner_sweep_own.md`.

Separately, the bundled
`data/predictions/captioner_sweep_per_object.parquet` carries per-UID
**NN-proxy** leak flags across the same four captioner corpora — i.e. for
each LVIS UID, one boolean column per captioner indicating whether the
test object's *nearest training-neighbor* caption under that corpus contains
the GT class string. This parquet supports an NN-proxy captioner-robustness
check (audit `data/audit/G4_C_captioner_sweep.md`) and is *not* the data
behind paper Table 1 rows 2-4. The two sweeps tell consistent stories about
captioner robustness but are different proxies and produce different
numbers (own-caption MH for cap3d_old is -9.76 pp; NN-proxy MH for the same
corpus is +30.86 pp — distinct quantities).

### Own-caption sweep (C12, C13; paper Table 1 rows 2-4) — requires external corpora

1. Stage each caption corpus (`cap3d_new`, `cap3d_old`, `sf_name_desc`,
   `sf_tags`) at a reviewer-chosen path.
2. For each corpus run
   `code/stratification/own_caption_proxy.py --captions <path>
   --gt-classes data/splits/lvis_eval.json --output /tmp/records_own_<corpus>.json`.
3. Then for each corpus run
   `code/stratification/cluster_bootstrap.py --records-json
   /tmp/records_own_<corpus>.json --n-iter 2000` and
   `code/stratification/mantel_haenszel.py --strata-json
   /tmp/strata_own_<corpus>.json --min-n 10`.

Expected per-corpus numbers are recorded in
`data/audit/G6_captioner_sweep_own.md` (cap3d_new marginal +11.82,
cap3d_old +8.44, sf_name_desc +11.42, sf_tags +11.66 pp; MH
-0.535 / -9.76 / +4.53 / +5.13 pp).

### NN-proxy sweep (C12-NN, C13-NN; audit G4_C; bundled-parquet only)

The bundled `captioner_sweep_per_object.parquet` contains per-UID
NN-proxy leak flags and per-captioner top-1 correctness columns for all
four captioners — the NN-proxy marginal and MH numbers can be derived
directly from this single parquet without staging caption corpora:

```bash
uv run python - <<'PY'
import pandas as pd
import json
from collections import defaultdict
import sys
sys.path.insert(0, 'code')
from stratification.mantel_haenszel import mh_risk_difference

df = pd.read_parquet('data/predictions/captioner_sweep_per_object.parquet')
captioners = ['cap3d_new', 'cap3d_old', 'sf_name_desc', 'sf_tags']
print(f"{'Captioner':14s}  {'marginal Δ (NN-proxy)':22s}  {'MH(min_n=10)':14s}  K")
for cap in captioners:
    leak_col   = f'{cap}_leak'
    corr_col   = f'{cap}_correct'
    sub = df.dropna(subset=[leak_col, corr_col])
    marg = (sub.loc[sub[leak_col]==1, corr_col].mean()
            - sub.loc[sub[leak_col]==0, corr_col].mean()) * 100
    strata = []
    for cls, g in sub.groupby('gt_first'):
        leak = g[g[leak_col]==1]; clean = g[g[leak_col]==0]
        strata.append({"class": cls,
            "n_leak": len(leak), "k_leak": int(leak[corr_col].sum()),
            "n_clean": len(clean), "k_clean": int(clean[corr_col].sum())})
    pt, _ = mh_risk_difference(strata, min_n=10)
    keep = [s for s in strata if s["n_leak"]>=10 and s["n_clean"]>=10]
    print(f"{cap:14s}  {marg:+9.3f} pp           {pt*100:+9.3f} pp     K={len(keep)}")
PY
```

Expected (NN-proxy, audit G4_C — *not* the paper Table 1 own-caption rows):

| Captioner | marginal Δ (NN-proxy) | MH(min_n=10) (NN-proxy) | K |
|---|---|---|---|
| cap3d_new | +47.69 pp | +31.45 pp | 310 |
| cap3d_old | +47.37 pp | +30.86 pp | ~310 |
| sf_name_desc | +44.22 pp | +25.34 pp | ~310 |
| sf_tags | +41.84 pp | +20.17 pp | ~310 |

**Wall-time:** ~30 s on the bundled parquet (no caption-corpus download
required).

---

## Reproducing the prune masks (Methods, Reproducibility appendix)

Claims: C42 (52 % prune ratio), C57 (prune masks).

### Inputs

- Cap3D captions (download separately).
- `data/splits/lvis_eval.json`
- `data/prune_masks/uid_universe.txt` (the 874,402-UID training pool ordered;
  positional alignment with the four `.npy` masks).

### Commands

```bash
# Baseline (Run-0): all-True mask
uv run python code/prune_masks/build_baseline_mask.py \
    --captions /path/to/cap3d_new.csv \
    --output   /tmp/prune_mask_0.npy

# Self-class (Run-A): drop UIDs whose caption contains their own GT class
uv run python code/prune_masks/build_self_class_mask.py \
    --captions   /path/to/cap3d_new.csv \
    --gt-classes data/splits/lvis_eval.json \
    --output     /tmp/prune_mask_A.npy

# Any-LVIS (Run-B): drop UIDs whose caption contains any LVIS class string
#   (length >= 7 to suppress short common-noun false matches; this is the
#    min_lvis_term_len=7 deviation justified in C42)
uv run python code/prune_masks/build_any_lvis_mask.py \
    --captions   /path/to/cap3d_new.csv \
    --lvis-names data/splits/lvis_eval.json \
    --min-lvis-term-len 7 \
    --output     /tmp/prune_mask_B.npy

# Random (Run-C): match-size random control to Run-A
uv run python code/prune_masks/build_random_mask.py \
    --captions       /path/to/cap3d_new.csv \
    --reference-mask /tmp/prune_mask_A.npy \
    --seed           42 \
    --output         /tmp/prune_mask_C.npy
```

### Expected output

Diff the produced masks against the shipped ones:

```bash
uv run python3 -c "
import numpy as np
for r in ['0', 'A', 'B', 'C']:
    a = np.load(f'/tmp/prune_mask_{r}.npy')
    b = np.load(f'data/prune_masks/run_{r}.npy')
    print(f'run_{r}: diff = {int((a != b).sum())} / {len(a)} ({(a!=b).mean()*100:.4f}%)')
"
```

Expect zero diffs (deterministic for runs 0/A/B; deterministic with `--seed 42`
for run C). Per-mask keep-counts:

```
run_0: kept= 874402 / 874402 (100.00 %)
run_A: kept= 419287 / 874402 ( 47.95 %)   # 52.05% pruned -- C42 (self-class)
run_B: kept= 850796 / 874402 ( 97.30 %)   #  2.70% pruned -- C42b (any-LVIS, NOT size-matched)
run_C: kept= 419287 / 874402 ( 47.95 %)   # 52.05% pruned -- size-matched random control
```

**Wall-time:** ~2 minutes per mask.

---

## Verifying anonymization

To confirm no author / hostname / SDK strings leak through any shipped file,
run the verification gate documented in `ANONYMIZATION.md`. A convenience
wrapper:

```bash
bash code/utils/verify_anonymization.sh .
```

(Exits 0 on pass, non-zero on fail.) The shipped package passes with zero
hits.

---

## Troubleshooting

- **`uv sync` resolves a different torch version.** Ensure your Python is
  3.10 or 3.11 (`uv python install 3.10` if not). The lockfile requires
  exactly `torch==2.4.1`.
- **Script can't import `utils.io`.** All scripts under `code/` extend
  `sys.path` to find the sibling `utils/` package when run directly. Make
  sure you are invoking the script from the supplementary directory (the
  one containing `pyproject.toml`), e.g. `uv run python
  code/stratification/own_caption_proxy.py --help`.
- **Per-class numbers differ by more than the stated tolerance.** Check
  that you are using the bundled `lvis_nn_assignments.parquet` predictions
  and not a re-derivation; check that the filter family is V2 (any-class,
  word boundary) for the headline numbers; D1-D6 and V1/V4a/V4b are
  sensitivity rows. Cluster-bootstrap CI width depends on `B`; the paper
  uses `B=2000`.
- **Cluster-bootstrap CI is much narrower than reported.** The
  `cluster_bootstrap.py` script always resamples at the class level (the
  unit of independence). Per-object bootstrap, which underestimates
  uncertainty, would have to be implemented separately — the bundled
  script does not have a per-object mode by design (see VERDICT
  Required Revision #3). If your CI is narrower than the paper's,
  re-confirm you are calling `cluster_bootstrap.py` and not your own
  per-object implementation.