# Reproducing the study:

The original final run is in `evidence/final_feedback.zip`. It contains all final raw attempts, reference solves, frozen inputs, source, Julia environment, hardware metadata and logs. Files in that archive retain their original bytes. `code/` is the same frozen source, exposed for inspection. The curated report and analysis scripts are separate from the measured implementation.

## Recheck the retained results:

Use Python 3.10–3.12 on Linux. The recorded execution used Python 3.11.2 and the direct versions in `requirements-observed.txt`. For numerical auditing, CPU PyTorch is sufficient. The direct-version list is an observed environment record; a complete Python transitive wheel lock was not captured. The Julia dependency graph is pinned in `protocol/julia_environment/Manifest.toml`.

```bash
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -e './code[test]'
python -m pip install -r requirements-observed.txt
python -m zipfile -e evidence/final_feedback.zip work/recorded
python scripts/recheck_results.py \
  --run-root work/recorded/final_check_v10_20261025_205933_14370 \
  --output work/recheck
```

The command checks all 307 frozen-file hashes, every final campaign denominator and endpoint, all attempted AC stage vectors, and the DataKit verification. It retains unresolved and economically unqualified cases. `--metrics-only` omits numerical physics rechecking and is explicitly identified in its output. Normal rechecking does not run GPU inference or Julia correction.

Recreate descriptive figures and tables from the included checked exports:

```bash
python scripts/compile_results.py \
  --run-root work/recorded/final_check_v10_20261025_205933_14370 \
  --package .
```

The script regenerates JSON/CSV summaries and the PDF/PNG/SVG figures. The report's `tables_generated.tex` contains the complete final table. With a full TeX Live installation, compile from the report folder:

```bash
cd report
pdflatex -interaction=nonstopmode -halt-on-error report.tex
pdflatex -interaction=nonstopmode -halt-on-error report.tex
```

## Rerun the frozen workload on OMNI:

This is optional reproduction after submission. The release already contains the completed final experiment. A complete rerun requires an NVIDIA GPU compatible with PyTorch 2.7.1+cu118, eight physical CPU cores per grid task, Julia 1.10.10 and the pinned Julia packages. GENCO runs on the GPU; IPOPT and MadNLP correction run on CPUs.

Start in the extracted package directory on an OMNI login node:

```bash
module load python/3.11.2 julia/1.10.10
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements-observed.txt
python -m pip install -e './code[test]'
python scripts/prepare_reproduction.py --destination work/rerun
export GENCO_RERUN_ROOT="$PWD/work/rerun"
export GENCO_CHECKPOINT_CACHE="$PWD/models"
export GENCO_JULIA_DEPOT="$PWD/.julia_reproduction"
export JULIA_DEPOT_PATH="$GENCO_JULIA_DEPOT"
export JULIA_PKG_PRECOMPILE_AUTO=0
julia --project="$GENCO_RERUN_ROOT/julia_environment" -e 'using Pkg; Pkg.instantiate()'
python -c 'from genco_resilience.workload_inference import fetch_checkpoints; fetch_checkpoints("code/workload_checkpoint_lock.json", "models")'
mkdir -p logs
sbatch scripts/rerun_omni.sbatch
```

The preparation script writes a new run containing the exact frozen source and inputs. It refuses to overwrite an existing destination. It leaves the original feedback unchanged. Checkpoints are downloaded at immutable revisions and verified by the inference adapter. The original launcher, module assumptions and submission wrapper are retained under `protocol/` for comparison; the supplied rerun batch file passes portable absolute paths explicitly.

After the array finishes, collect on an allocated CPU node or through an OMNI CPU batch job:

```bash
export PYTHONPATH="$GENCO_RERUN_ROOT/source_snapshot/src"
python -m genco_resilience.final_check_run collect --run-root "$GENCO_RERUN_ROOT"
```

An unsuccessful numerical or method check returns a nonzero status and preserves results. Run `scripts/recheck_results.py` against that new run to make a separate recheck export.

## Hardware and numerical contract:

The report gives actual final nodes, V100 model and driver, EPYC model, allocations, affinity and software versions. `results/recheck/hardware_and_qualification.json` contains full recorded GPU UUIDs, CPU sets, model parameter hashes, checkpoint revisions, startup times and inference qualifications. Both source implementation and `protocol/input_suite.yaml` preserve the service, lexicographic, feasibility and economic tolerances. The final generator seed is 20261031. Final demands belong to previously known test topology families; GENCO training overlap is unknown.

Seven single-thread CPU solver workers share the allocation with one coordinator. Persistent Julia children share their corresponding worker core. Numerical correction uses Float64. GPU eager/replay checks use fixed per-unit tolerances; the four-layer model is an approximate truncated computation. Warm campaign timing includes prediction, queueing, correction, verification, file output and producer tail. Compilation, model loading, qualification, scheduler waiting and final archive collection are recorded separately. Reproduction should report its own timing distribution and runtime/library differences.
