docs/split_protocol.md

# Code-ATLAS split protocol

## Objective

Create per-language held-out code for stable next-token loss while preventing the
same repository, code clone, or algorithmic problem from appearing in both train
and evaluation.

ATLAS isolates, for each natural language, `min(20M tokens, 20% of available
tokens)` from MADLAD-400 and also evaluates on the external parallel FLORES set.
Code-ATLAS will preserve that loss-test token target, but randomize over grouped
repository components instead of individual sequences.

## Required order of operations

1. Freeze every upstream artifact revision and capture its source metadata.
2. Normalize language labels without discarding the original label.
3. Apply the license policy and quality filters.
4. Compute exact content hashes across all sources.
5. Form near-duplicate file clusters across all sources and languages.
6. Form repository lineage components from forks, origin metadata, shared commit
   history when available, and high file-set similarity.
7. Attach task artifacts to an underlying problem family (for example HumanEval
   task ID or CodeNet problem ID), independent of programming language.
8. Construct a union graph whose edges are repository lineage, exact duplicate,
   near duplicate, or problem-family membership. A connected component is atomic.
9. Deterministically assign atomic components with frozen salt `code-atlas-v1`,
   minimizing relative target error jointly across language token vectors. Fill
   test quotas first and validation quotas second; never split a component.
10. Run a post-split contamination scan before publishing IDs or training.

## Test surfaces

### Held-out repository loss

Freeze one Code-ATLAS reference tokenizer and a byte/file-span manifest before
splitting. For language `l`, let `U_l` be unique post-filter, post-dedup reference
tokens. Target `loss-test_l = min(20,000,000, 0.20 * U_l)`, matching ATLAS, and
target `loss-val_l = min(2,000,000, 0.10 * U_l)` for checkpoint selection. Training
gets the remainder. Group-boundary overshoot or undershoot is allowed and reported.
Require at least three independent repository-lineage components or mark that
language unsupported for three-way loss evaluation.

The frozen span manifest makes every model see identical text even if it uses a
different tokenizer. Report bits per UTF-8 byte or ATLAS's cited
vocabulary-insensitive loss, not raw tokenizer cross-entropy. Cap a single repo
lineage at 1% of a language loss sample and bootstrap confidence intervals by
repo-lineage ID.

### Parallel semantic loss

Reserve complete problem families across languages. This is the code analogue of
ATLAS's external parallel test, but it must never share an underlying task with
`parallel_aux` training records.

### Functional evaluation

Keep at least one executable benchmark artifact entirely untouched. Functional
scores are secondary diagnostics; held-out loss is the primary scaling-law
response.

For functional task corpora, create a cross-language `problem_family_id` before
splitting, then assign complete families 70/10/20 to task-train/dev/test. All
translations, solutions, tests, mutations, and same-problem judge submissions move
together. Bootstrap reported scores by problem family, not translated row.

### Temporal loss

Maintain a separately named post-cut `loss-future` panel. Its repository families
must first appear after a preregistered cutoff according to trusted forge/archive
time, with no earlier fork/clone ancestor, and must survive deduplication against
pre-cut data. Never average `loss-future` into the ATLAS-comparable IID test.

### Scaling-law fit holdouts

These are distinct from corpus splits. Reproduce ATLAS's fit tests: random 20% of
run observations, top 20% of training-token horizons, selected scales at roughly
660M and 8B parameters, largest-compute observations, and unseen mixture
configurations. ATLAS does not state a percentage for the largest-compute holdout;
use its released run IDs if available or preregister a new rule and label it as a
Code-ATLAS clarification. `C=6ND` applies to dense decoders; otherwise report
measured FLOPs.

## Non-negotiable leakage rules

- Never split by file alone.
- Never split translated rows of the same task across partitions.
- Never count repeated task translations as independent unique-code volume.
- Never duplicate a Nebius repository once per task row.
- Never allow a benchmark used for training to retain its standard benchmark name
  in reported evaluation results.
- Never assign a split before global cross-source deduplication.