# Referee Checklist (30–45 minutes)

## Overview

RU is a certificate engine for universality and obstructions in constrained nonnegative propagation. Host structures supply finite inputs. Outputs are audited certificates or finite obstruction witnesses.

## Step 1 — Confirm the engine interface

Open:

- `sources/ru/robust_certificate_schema.json`
- `sources/ru_bridge/bridge_certificate_schema.json`

Check that:

- a robust certificate records: tight core, Doeblin data (or δ=0), recurrence/obstruction, rate pack, ε*
- a bridge certificate records: the host context, the reduction, and pointers to the robust certificate object

## Step 2 — Verify a real-host contraction success case

Use the Fibonacci real-host contraction artifact:

- `docs/Fibonacci_Contraction_Certificate.md`
- `sources/host_data/fibonacci_fusion_data.json`
- `sources/ru/robust_certificate_fibonacci_realhost_contraction.json`

Quick checks:

- Multiply N_tau by itself to confirm N_tau² is strictly positive.
- Confirm δ and U reported match min/max entries of N_tau².
- Confirm τ formula matches the value recorded in `rate_pack`.
- Confirm recurrence is RC1 with a finite gap bound (the engine uses B=0 in the toy constraint scheduling).

## Step 3 — Verify each obstruction class exists as an audited object

Use the artifact index:

- `docs/Artifacts.md` (generated)

Confirm you can find:

- OG1 periodic-core witness (period list, aperiodic_scc_count=0)
- OG2 active-face inconsistency witness (explicit contradiction)
- OG3 no-Doeblin witness (δ(w)=0 for all words on the full cone)
- OG4 avoidable Doeblin witness (explicit avoidance cycle)

Each must have:

- a bridge wrapper under `sources/ru_bridge/bridge_certificate_*.json`
- a robust certificate under `sources/ru/robust_certificate_*.json`

## Step 4 — Confirm reproducibility

Run:

- `python tools/run_all_examples.py`

Then build the index:

- `python tools/build_artifact_index.py`

If you want the global layer:

- `python tools/build_fibonacci_alpha_chambers_report.py`

## Step 5 — Decide what is actually being claimed

The engine’s core claim is:

- **method universality**: RU turns finite host reductions into either contraction certificates with rates, or finite obstruction witnesses.

The engine does not claim:

- that string theory is experimentally verified
- that every string construction fits RU

The engine does claim:

- when a string/CFT-derived host reduction fits the finite positivity template, universality is decidable/quantifiable via certificates.


## Optional mechanical audit

- Run: `python tools/audit_sanity_checks.py`


## Additional real host dataset check

- Toric code OG3 artifact:
  - `sources/host_data/toric_code_fusion_data.json`
  - `docs/OG3_ToricCode_NoDoeblin.md`
