# v1.0 reproducibility and independent replication

The public release contains source, synthetic demonstrations, complete numerical
receipts, and independent audits. Original checkpoint files, calibration/fresh
tokens, teacher/student activations, fitted model arrays, optimization states,
and real-model finite wire payloads are excluded. Their recorded hashes remain
public. A new replication downloads the exact public inputs and builds a
separate experiment. It must never overwrite the published once-only journals.

## 1. Install the recorded CPU environment

Use Python 3.12 in a fresh environment. From the extracted release directory:

```bash
python -m pip install torch==2.14.1+cpu --index-url https://download.pytorch.org/whl/cpu
python -m pip install -r requirements-recovery.txt
```

The CPU index must remain available when resolving the `+cpu` Torch package.
For an installer that resolves all requirements together, use:

```bash
python -m pip install -r requirements-recovery.txt --extra-index-url https://download.pytorch.org/whl/cpu
```

The recorded experiment uses NumPy 2.3.5, SciPy 1.17.0, Torch 2.14.1+cpu,
Transformers 5.19.0, Datasets 5.1.0, Hugging Face Hub 2.2.0, Safetensors 0.8.0,
and Tokenizers 0.23.3. The public requirements pin the main numerical and model
packages. CPU architecture and BLAS behavior can still change floating-point
results; a replication is a new run with its own source/input receipts.

## 2. Create an empty, separate experiment and recover inputs

Choose an unused directory outside the extracted release. The
`<replica>/working/embrace` layout matches the existing experiment entry points,
which locate their cache two directories above the project.

```bash
python v1_rebuild_inputs.py --project-root /absolute/path/eve-v1-replica/working/embrace
cd /absolute/path/eve-v1-replica/working/embrace
```

The helper refuses the original project, its cache root, nonempty destinations,
and nested destinations. It copies public sources and preserves the published
v1 receipts under `reference_results/original_v1`. New receipts go to `results`.
It performs no neural forward pass and no quantizer fitting.

The exact download identities are:

| Input | Identity | Pinned revision |
|---|---|---|
| Model and tokenizer | `facebook/opt-125m` | `27dcfa74d334bc871f3234de431e71c6eeba5dd6` |
| Dataset | `Salesforce/wikitext`, `wikitext-2-raw-v1` | `b08601e04326c79dfdd32d625aee71d232d685c3` |

The helper verifies all seven downloaded model/tokenizer asset lengths and
SHA256 digests, then checks the six original FP32 projection hashes from the
preserved v0.6 protocol. The `pytorch_model.bin` download is 250,540,281 bytes,
SHA256 `2d74da6615135c58cf3cf9ad4cb11e7c613ff9e55fe658a47ab83b6c8d1174a9`.
Checkpoint and dataset licensing remain those of their upstream publishers;
this release supplies neither original assets nor a new license for them.

Token preprocessing concatenates each dataset split independently with two
newline characters, then applies the pinned tokenizer with
`add_special_tokens=False` and no truncation. Contexts reset every 128 tokens.
The calibration input is the first 8,192 train tokens, shaped `64 × 128`.
The reserve fit uses contexts 0–47 and its development selection contexts
48–63. All 64 contexts are already used by the base quantizer fit; the reserve
development split is not an independent base-quantizer holdout.

| Token content | SHA256 of contiguous little-endian int64 token bytes |
|---|---|
| Original calibration, train `0:8192` | `dd50ee9bd68ba66fcc8c1f81a561429a502c24cfb208efe1df47f2f95ee61689` |
| Entire test split, 287,644 tokens | `98f0f6d425c82678630a55c6f20ba3d873889195e133e6eeb6166bbe5f22f104` |
| v1 test window, test `81920:90112` | `4f5293e497155b46c6ec195bab9e73b62e6dfa23a29a840fa15dceda14b1832d` |

The original v1 test window is excluded from fitting and role selection. A
replication of its 64 contexts measures reproducibility of published scores;
it does not create new untouched evidence for the original experiment.
Every new experiment has its own once-only evaluation journal.

## 3. Rebuild teacher evidence and the four base controls

Read the printed model directory, also recorded as `model_dir` in
`results/v1_recovery_environment.json`. Substitute that absolute directory for
`MODEL_DIRECTORY` in these commands:

```bash
python v1_teacher_collect.py --model-dir MODEL_DIRECTORY --tokens private/recovery_env/tokens_train.npy --threads 2
python v1_base_build.py --workers 4
python examples/check_v1_base_decode.py
python v1_select_release.py --stage freeze
```

Teacher collection records all native first-block projection inputs, original
weights, second moments, selected top-32 IDs, and direct tail logsumexp. Base
building creates binary, source hybrid-fork, one-bit scalar, and two-bit scalar
controls for all six complete first-decoder-block projections. These are
independent research reference implementations; the scalar controls are not
the official GPTQ software. Original base and fork sources remain byte-preserved
in the release history. Neither step reads fresh-test labels.

## 4. Freeze and run both matched nonlinear repair families

```bash
python v1_gauge_reserve_fit.py --freeze-only --model-dir MODEL_DIRECTORY --threads 4
python v1_gauge_reserve_fit.py --run
python v1_lowrank_gauge_fit.py --freeze-only --model-dir MODEL_DIRECTORY --threads 4
python v1_lowrank_gauge_fit.py --run
```

The sparse family has supports of 16 and 256 columns; the dense matched control
has ranks 3 and 51. Both use the same three bases, calibration split, terminal
33-category teacher KL, four optimizer epochs, and five decoded finite
checkpoints including epoch zero. All 60 checkpoints are retained. Paid FP16
weight and bias reserves, sorted sparse column IDs or both dense factors, all
six base projection frames, metadata, checksums, and the complete EEB1 envelope
are included in every reported candidate cost. Actual strict decoding followed
by FP32 installation defines the scored native model.

The recorded repair protocols use four CPU threads per family. The original
run executes both families concurrently, for eight CPU threads in total. The
ordered commands above also work sequentially; keeping each family's frozen
thread count preserves its declared numerical protocol. Teacher collection
uses two threads.

The fitters refuse an existing start journal or result. A start journal remains
as the original exclusive execution marker; the separate completed result
holds all checkpoint evidence. Do not delete a journal to resume or retune.
For a failed replication, preserve the failed directory and start a separately
identified replication.

## 5. Score the fourth bare control and freeze development selection

```bash
python v1_select_release.py --stage prepare-gptq1
python v1_select_release.py --stage score-gptq1 --frozen-protocol-sha256 PRINTED_GPTQ1_PROTOCOL_SHA256
python examples/check_v1_release_evidence.py --pre-model --threads 2
python v1_select_release.py --stage propose
python examples/check_v1_release_evidence.py --native-calibration --threads 2
python v1_select_release.py --stage finalize --independent-evidence results/v1_calibration_objective_evidence.json
```

The catalog contains 60 checkpoints plus four bare incumbents. Checkpoints
whose decoded native train KL exceeds their own epoch-zero train KL are
retained in the catalog and excluded from role admission. Primary and extreme
roles minimize development teacher KL under the actual complete bare two-bit
and one-bit EEB1 caps respectively. Ties use complete byte count and stable
candidate name. Source hybrid-fork variants are retained under the same caps,
including when another family wins globally. The independent native audit
replays teacher and selected calibration endpoints without NLL, fresh data,
or an optimizer. It checks direct tail geometry and the sharp gauge bridge.

## 6. Freeze every profile before one fresh evaluation

```bash
python v1_model_probe.py --stage prepare
python v1_model_probe_release.py --stage freeze --threads 4
python v1_model_probe_release.py --stage evaluate --frozen-protocol-sha256 PRINTED_MODEL_PROTOCOL_SHA256
python examples/check_v1_release_evidence.py --post-model --threads 2
```

Use the exact SHA256 printed by the preceding freeze command. The evaluation
entry point refuses a preexisting result or start journal. The full native
curve, chosen roles, paid bytes, model configuration, source closure,
development evidence, and token identities are frozen before the first fresh
next-token loss. Exactly identical installed six-weight-plus-bias states share
one native score and remain explicitly labeled as aliases. All other 66
projection weights, embeddings, normalization parameters, and remaining biases
stay FP32. The reported block rate is not a whole-model sub-two-bit rate.

The release entry point uses a strict canonical JSON comparison for native
configuration metadata. JSON converts Python integer dictionary keys to string
object names; this comparison checks serialization equivalence, rejects key
collisions and nonfinite values, and does not change the model or configuration.
The original run preserves a recorded zero-forward preflight rejection by its
earlier direct-dictionary guard. A clean replica freezes directly with both the
rejected-protocol and failure records absent. It must not fabricate that historical
failure. A partially copied preflight pair is rejected. Original token preparation
through `v1_model_probe.py --stage prepare` remains valid.

## 7. Verify the release and build a separate replication report

```bash
python finalize_v1_release.py --record-tests
python finalize_v1_release.py --check
```

The check also requires a current independently recorded manuscript visual-QA
receipt; it does not create a manuscript or claim that a new replication has
the original report. Author and render a report for the new evidence, review
every page, record its current hash in `results/V1_PDF_QA.json`, then finish:

```bash
python finalize_v1_release.py --write-receipt
python package_v1_release.py --output-dir /absolute/path/eve-v1-replica/deliverables
```

The packager rejects private/model/data leakage, snapshots all public file
hashes, creates root indices with explicit self-hash exclusions, and reopens
the ZIP to verify its exact member set, CRC, every hash and length, source
stability, and standalone/archived PDF identity. It performs no fitting or
neural inference. Matching short-window results on this small partial-model
study demonstrates replication; broader model, corpus, full-model compression,
and compressed-kernel comparisons are required for a SOTA claim.