Objective vs. Search: Decomposing What Makes a Good TokeniserAhmetcan Yavuz, Clara Meister, Tiago PimentelEMNLP 2026 · arXiv 2609.19145 · tested 2–3 October 2026
Read paper

Does the way we split text matter most?

Numbers hold. Claim unclear.

92/96 Table 1 values reproduced. In our tiny model, BottomUpLL was +0.0486 BPB worse than UnigramLM (95% CI +0.017 to +0.080).

1 confirmed3 fine print2 not confirmed1 couldn't test

The idea, in 6 seconds

“Photosynthesis converts carbon dioxide and water into glucose and oxygen.”

Bottom-up · merge pairs11tokens
Top-down · prune13tokens
Two ways to choose word piecesReady
MEASURED RESULT · 92 OF 96 PUBLISHED TABLE 1 VALUES REPRODUCEDTINY-MODEL BPB DIFFERENCE +0.048695% CI +0.017 TO +0.080 · FIVE PAIRED SEEDS

The verdicts

Tap any card

Paper vs. ours

Tap a dot to inspect any Table 1 value

Select a dot for the tokenizer, paper value, and our value.

Within toleranceOutside tolerance

Follow the five seeds

Held-out bits per byte · lower is better

Four matched tiny GRUs, 160 updates per run. This does not test the paper's 100M–1B transformer claim.

Lab notebook

Expert view

CSV-derived values · five paired seeds

Fig. 1 Intrinsic Table 1 check

All 12 English tokenizer JSONs; 92/96 values within predeclared tolerances. The four misses are 128k vocabulary utilisation on a smaller test set. Full 96 rows: paper_comparison.csv.

Fig. 2 Vocabulary overlap, 128k

Shared vocabulary as a percentage of each 128k vocabulary. Green cells share more pieces; paper Figure 3 cells reproduce to one decimal. Source: vocab_overlap.csv.

Fig. 3 Tiny-LM contrasts

Two-layer 1,315,842-parameter GRU; five paired seeds 42–46, same raw chunks, 160 updates, same five held-out slices. CI is a paired-seed t interval conditional on this setup. Sources: tiny_lm.csv, tiny_lm_contrasts.csv.

Fig. 4 Fork build and retrain

The Python binding built offline into the case-local venv. Adapted BPE 8k retraining on 2,000 shard documents was deterministic across two runs: identical model hashes and token counts, with 7,019/8,000 entries (87.74%) shared with the shipped JSON. The original training script lacked offline dependencies; this is an adapted run.

Source: local case 005 RESULTS.md and results/fork_retrain.csv. Public segmentation totals: examples.csv.

Fig. 5 Code audit · second review

Self-pair scoring differs from the written rule; retraining changed fewer than 0.3% of vocabulary entries at 8k–32k and compression by under 0.01%. TopDownComp prunes 10% of the excess above target; the written rule says 10% of the current vocabulary. Small retraining changed about 4–6% of entries and compression by under 0.04%.

Both findings were confirmed by independent source review and retraining. Public data: self-pair, 50k→8k pruning, 10k→2k pruning.

Reproduce Exact commands in the source case folder

python scripts/intrinsic.py --docs-per-sample 2000
python scripts/examples.py
python scripts/tiny_lm.py
python scripts/validate_results.py
Requires the case 005 local data, tokenizers and Python environment described in RESULTS.md. Each public chart constant is rebuilt from the seven CSVs by python papers/2609.19145/rebuild_case.py.

How we checked

Seven checks, with limits shown

Case 005 / findings / 3 October 2026

The full findings

Published intrinsic results largely reproduce: 92/96 Table 1 values and the reported overlaps and examples match. Our 1.32M-parameter test found no bottom-up advantage: BottomUpLL was 0.0486 BPB worse than UnigramLM (95% CI +0.017 to +0.080). This scale cannot settle the paper.

Original authors: Ahmetcan Yavuz, Clara Meister, Tiago Pimentel · Read the paper ↗

Tested 2–3 October 2026Published 2026-10-03Raw CSV below

Paper versus our measured bytes per token for all 12 English Table 1 tokenizers; diagonal means exact agreement. This is one of eight Table 1 metrics, and the full 96-value comparison is downloadable.

What the data says.

This table contains the measured comparison behind the answer. The expert sections below explain how the numbers were produced and what they cannot establish.

TokeniserMean tiny-model held-out BPBSearch
BPE3.3260Bottom-up
BottomUpLL3.4491Bottom-up
TopDownComp3.3175Top-down
UnigramLM3.4005Top-down

Claim-by-claim verdicts.

Confirmed means supported within the stated test; Partly confirmed keeps a tested piece separate from an untested part. Not confirmed means the tested evidence did not show the claim. Could not test marks missing evidence or an inapplicable setup.

ClaimVerdictEvidence boundary
Search dominates objective downstreamNot confirmedTiny GRU contrasts point the other way; paper-scale transformers unavailable.
Bottom-up lower downstream BPBNot confirmedBottomUpLL was 0.0486 BPB worse than UnigramLM in the tiny check.
Table 1 intrinsic measurementsPartly confirmed92/96 within stated tolerances; four 128k utilisation misses.
Published vocabulary overlaps and examplesConfirmedFixed vocabularies and example totals reproduce to reported precision.
Multilingual and BLiMP outcomesCould not testMissing five-language test union, checkpoints and BLiMP data.

Lab notes and sources.

Expert detail: measurements and interpretation

The Table 1 check used the shipped tokenizer JSONs on five disjoint windows totaling 10,000 FineWeb-Edu documents. Corpus totals were normalized to the paper's reported byte size; this does not recreate the authors' exact held-out split. The four tolerance misses concern 128k vocabulary utilisation, which depends strongly on test-set size. All published Figure 3 overlap cells and the ten illustrative segmentation totals matched the released assets at their printed precision.

For a downstream diagnostic, each of four independently trained tokenizers fed the same two-layer, 1,315,842-parameter GRU design over five paired seeds. Each seed used the same raw text chunks and 160 updates. We measured held-out bits per byte on the same five slices. BottomUpLL minus UnigramLM was +0.0486 BPB, with a paired-seed 95% t interval of +0.017 to +0.080. That interval describes seed variation conditional on this tiny setup; it says nothing direct about the paper's much larger transformers.

The authors' core claim concerns 100M–1B-parameter language models. Those checkpoints, BLiMP data, and a five-language test union were not supplied in this local case. Our tiny result did not show the claimed bottom-up advantage, but small scale cannot settle the paper's conclusion. The two paper/code differences below have since passed second review. Their measured effects were minor.

How we tested

We ran published tokenizer JSONs on five disjoint FineWeb-Edu windows, checked intrinsic metrics against independent arithmetic, and compared all 96 English Table 1 cells with predeclared tolerances. Vocabulary overlap and example outputs were cross-checked separately. We then trained four matched tiny GRU language models over five paired seeds and measured byte-weighted held-out bits per byte.

Limitations and next check

The exact paper training and test splits, 100M–1B transformer checkpoints, multilingual test union and BLiMP data were unavailable. Four 128k utilisation values missed tolerance on our smaller test set. The tiny GRU is a diagnostic, not a paper-scale replication; its paired-seed interval does not transfer to large models.

Where the released code differs from the paper

Our agents flagged these during the code audit. A second, independent reviewer then confirmed both by reading the code and retraining both ways. Both are minor: neither changes the paper’s results. We have not yet heard from the authors. Data: self-pair retraining, pruning schedule (50k→8k), pruning schedule (10k→2k).

Minor, results unaffected: Self-pair counting. When choosing merges, the released code counts overlapping repeats such as “...” or “www” (standard HuggingFace behaviour). It also does not apply the paper’s special formula for merging a token with itself. The paper describes the non-overlapping rule as what its implementation does. Retraining both ways changed fewer than 0.3% of vocabulary entries at 8k–32k (up to 3% at a toy 2k size), and compression by under 0.01%.

Minor, results unaffected: TopDownComp pruning rate. The paper says each round removes 10% of the current vocabulary. The released code removes 10% of the tokens still above the target size, which is a finer schedule. In our small test this changed about 4–6% of vocabulary entries and compression by under 0.04%. Mainly it makes training slower (roughly 2.5–6× more rounds); it does not change results.

Original sources, data and corrections

The ideas and original claims belong to the paper authors. Kael Research is responsible for these implementations, checks and interpretations. Original source: Objective vs. Search: Decomposing What Makes a Good Tokeniser (2026-09-16)
By Ahmetcan Yavuz, Clara Meister, Tiago Pimentel. Download each public CSV below; the full experiment repositories, including any larger uncopied raw artifacts, are available on request. For corrections, see our public log or contact us through the site.

Got a paper? We'll test it.

Paper: Ahmetcan Yavuz, Clara Meister, Tiago Pimentel, “Objective vs. Search: Decomposing What Makes a Good Tokeniser”, EMNLP 2026 (PDF). All credit for the ideas belongs to the authors; the implementations and measurements here are ours. Tested 2–3 October 2026; authors have not yet reviewed this report.