# Contextual dense RLVR: compact evidence

This is a review bundle for one frozen development experiment, not a claim of
replicated mathematical improvement or a new distillation algorithm. Read
`analysis/descriptive_report.md`, the contract, and the publication that links
this archive for scientific interpretation. The focal learner is contextual
own-teacher JSD plus terminal RL; controls are ordinary RL, empty-template JSD,
verified hard replay, and the unchanged warm checkpoint.

## What is checkable

All8192 extracted training candidates, all2560 extracted native candidates,
lengths, EOS/reward flags, donor/receiver roles and relevant group records are
included as compact tables with explicit column schemas. No adverse arm or
failed spending gate is omitted. `code/check_contextual_evidence.py` checks file
hashes, reconstructs group advantages/masks/update counts, regrades every
extracted candidate, and recomputes the four native paired100000-resample
contrasts and the fixed gate. It verifies the declared chunk/first-record sample identities and independently re-extracts exactly26 full
responses chosen as the first physical record of each training/native chunk.
The selection was documented before native generation.

The remaining full text/token records and model weights are not in this compact
archive. Their hashes identify author-held originals but do not make them
publicly inspectable. The author audited every raw re-extraction and recorded neural execution;
there was no independent full optimizer replay. The compact public checker
cannot independently re-extract the omitted responses. Full-retention target inputs and before/after likelihood records are
included, but independently recomputing likelihood needs the trained weights.
A reported component norm is an instrumented observation, not a public
parameter-gradient replay.

## CPU verification

Packaging revision 2 adds the omitted baseline `utils.py` and `ch02.py` import
dependencies. The initial import failure is retained locally. No experimental
input, outcome, fixed raw sample or statistical rule changed.

Use the task supplement's pinned environment and data. This bundle includes its
compatible model/grader modules, preserving Apache-2.0 attribution in
`code/vendor/LICENSE`; added research code is supplied under the same license.
No model weights or third-party reasoning demonstrations are redistributed.
From the bundle directory, with an output directory OUTSIDE it:

```bash
python code/check_contextual_evidence.py --data /path/to/task/code/data --output /path/to/new/audit
```

This requires NumPy, PyTorch, tokenizers, SymPy and the pinned baseline packages.
It runs on CPU and stops if any grade is unresolved; timeout is not an incorrect
answer. The result is `PASS` only after all structural/regrading checks succeed.
Data and tokenizer SHA256 are checked against the frozen contract.

## Executed recipe and regeneration limits

The original training/evaluation/analysis code and all39 input hashes are in the
bundle. Large shared task inputs and the warm checkpoint are omitted. The warm
checkpoint came from the supplied50-update recipe, seed17041; ancestry config
and loop-time summary are included. Retraining with that seed is regeneration,
not a guarantee of bitwise equality with the historical checkpoint. A fresh
independent replication must use its own warm readout, new run name/output paths,
and an explicitly refrozen input manifest. Do not replace a checkpoint while
retaining the old hash or historical warm answer vector.

`run_contextual_rl_queue.py` documents the actual sequential orchestration:
G/C/E/H training, then W/G/C/E/H native generation, then the full audit/readout.
Every GPU job used `./gpu-run -- python ...`, one GPU at a time and less than one
hour per job. The helper is workspace infrastructure, not a bundled portable
scheduler. No native candidate was graded before all endpoints completed.
The immutable original split and contract are supplied; rebuilding them is not
necessary to inspect this historical run. The original split-construction
script references historical exclusion ledgers; the resulting complete protected
index list is in the supplied split.

This archive does not claim to be a one-command historical neural replay:
checkpoint references inside executed summaries retain original paths, and the
historical warm checkpoint is not publicly hosted. For a fresh permitted run,
place supplied data in code/data, regenerate the declared warm recipe, retain
exact source/target provenance, and create a new reviewed contract rather than
editing this historical evidence. Use the public paper12v1 supplement for the
prior contextual source study; its evidence is not duplicated here.

## Costs and interruption

The integrated report includes allocated GPU time, logical matrix/attention
proxies, source-retention/diagnostic work, and the interrupted G attempt's
conservative timing bounds. Readiness/probes and shared warm/source ancestry
remain additional costs. Proxies are not measured hardware FLOPs. The incomplete
attempt is preserved in the original workspace; its record is included here.
The restarted chunk replayed logged samples and scalar update records, but
uncheckpointed parameter tensors were unavailable for a bitwise comparison.
