Zain Dana Harper Map

Elements Swatches Studies Site index

Findings F515 Information and signal, Computing and mathematics, Language and literature found 2026-11-01

A small language model squeezes the UDHR to 0.27 bits a character, and fresh text to 1.59

Used as a compressor, SmolLM2 encodes the English Universal Declaration of Human Rights at 0.27 bits per character, far below any classical compressor. On 30,000 characters written after its training it needs 1.59, which points at the model having seen the declaration. One fresh text cannot say how large that share is.

Tier
B, signal
Outcome
held
Rung
none assigned
Kill rule
not fired
Corrections
2, latest 2026-11-14
Version
v3, 2026-11-14
Redo it
Reproduce

Download PDF 500 KB BuildTeX source F515.bld

What this means for a reader

When a paper or a model card reports how few bits a language model needs per character, ask what text it was measured on. On a famous public document, the number measures recall of that document as much as modelling of language. On text the models could not have seen, their lead over a classical compressor shrinks from about tenfold to under twofold. Check a compression figure on fresh text before reading it as either.

Objection

There is one unseen text. It is our own technical writing in one register, full of numbers and technical terms, and it was chosen after the headline numbers were seen. A set of fresh texts across registers is needed before the size of the memorisation share can be stated.

What would change the call. Our publication register records no condition that would raise or overturn this call.

From the paper's first stated limitation; our register records no separate objection.

Abstract

A language model that predicts the next word well is also a compressor, and its compression rate is often quoted as a measure of how well it models text. We used two small open models, SmolLM2-360M and Qwen3-0.6B, as arithmetic coders and compared them with xz and with a PPM context model. SmolLM2 encodes the English Universal Declaration of Human Rights at 0.27 bits per character, and Qwen3-0.6B at 0.57. The best classical coder, PPM trained on 5 million characters of Project Gutenberg, needs 1.99. We then added a control we had not planned: 30,000 characters of our own technical writing from October 2026, written after both models were released. On text written after their training, the two models need 1.59 and 1.66 bits per character. Cold PPM, which has seen nothing, finds the unseen text only slightly harder than the declaration: 2.70 against 2.57 bits per character. The models' advantage on the declaration therefore points at their having seen it; one fresh text cannot size that share. An arithmetic encoder and decoder round-tripped a 120-token passage exactly with both models.

c1 observed, evidence for claim 1
The numbers in claim 1
2; 0.27; 3; -0.6; 0.57 matches the result file, 2026-11-09
Chart 3
What each coder needs per character on three texts.
Chart 4
What it costs to send a right answer and a wrong one, given the question.
Basis
observed: measured in this study, with a result file
c2 observed, evidence for claim 2
The numbers in claim 2
1.59; 1.66 matches the result file, 2026-11-09
Chart 5
From a text the models may have seen to one they cannot have seen.
Basis
observed: measured in this study, with a result file
c3 observed, evidence for claim 3
The numbers in claim 3
2.70; 2.57 matches the result file, 2026-11-09
Chart 5
From a text the models may have seen to one they cannot have seen.
Basis
observed: measured in this study, with a result file
c5 observed, evidence for claim 5
The numbers in claim 5
120 matches the result file, 2026-11-09
Chart 2
Are the model rows real codes that decode back to the text?
Basis
observed: measured in this study, with a result file

Introduction

A model that assigns a probability to each next symbol can drive an arithmetic coderDefinition: arithmetic coding data compression A method that turns a model's probability for each next symbol into a single binary number, so a symbol given probability p costs close to minus log2 p bits, and a decoder with the same model recovers the text exactly. Excludes codes that give each symbol a fixed whole number of bits, such as Huffman codes. full definition, which spends close to minus log⁡2p bits on a symbol given probability p and lets a decoder with the same model recover the text exactly. The better the predictions, the shorter the code. Delétang and colleagues [1] used this equivalence to show that large language models are strong general-purpose compressors, and pointed out that counting the model's own size changes the picture. Huang and colleagues [2] found that compression on external text corpora tracks benchmark scores almost linearly across about thirty public models, and proposed compression as an evaluation measure.

Compression on public text has a known weakness. If the text was in the training data, a model can predict it from memorisationDefinition: memorisation machine learning; in evaluation also called training-data contamination A model's ability to predict a specific text because that text, or close copies of it, was in its training data, as distinct from predicting text of the same kind it has not seen. Excludes any claim about how the model stores the text internally. full definition, recall of that text, and not from a general model of language. Li and colleagues [3] built an evaluation on this point: they measured compression on Wikipedia, news, code and arXiv text dated before and after each model's training cutoff and reported that the rate worsens after the cutoff for many models.

Our question is smaller and concrete. How many bits per characterDefinition: bits per character information theory and data compression The length of a compressed text in bits divided by the number of characters in the original. Lower is better, and 8 is the cost of plain one-byte text. Excludes bits per token or per byte, which divide by a different count. full definition do two small open models need on a famous public document, against classical compressors, and how much of the result survives on text written after they were trained?

Preregistration and design

This test is one part of a larger study of language as a code. Its preregistrationDefinition: preregistration research method (metascience) A dated written plan for a study, fixed and hash-locked before any result is seen: the question, the data, the statistic, the controls, the forecasts and the kill conditions. Excludes a plan revised after looking at the outcome, and a protocol written only for the record after the run. full definition, a dated plan fixed and hash-locked before any result is seen, is a forecast file written and hashed on 1 November 2026 at 03:14 UTC, before any measurement. A first work session wrote it and stopped with no measurement saved. A second work session wrote a file of scoring rules 13 minutes later, before computing anything, and ran every measurement after that. A point forecast holds if the measured value is within 25 percent of it, and an inequality forecast holds when the inequality is true.

For this part the forecast file fixed:

  • The bits per character on the English declaration: xz 3.0, PPM cold 2.4, PPM trained on Gutenberg 2.1, SmolLM2 1.2, Qwen3 1.0.
  • On a held-out Gutenberg book: xz 2.9, trained PPM 2.1, SmolLM2 2.0.
  • That SmolLM2 needs at least a billion characters to pay for its own size against xz, and trained PPM at most 200 million.
  • A kill condition, a rule that decides against the run with no judgement after it: if an arithmetic-coded round trip with a model is not exact, the model rows count only as ideal lengths and not as real codes.
  • Forecasts for the cost of sending known answers, and a shuffled-training control for PPM.

The unseen-text control was not in the forecast file. It was added after the declaration came in at 0.27 bits per character under SmolLM2, to test whether that number was memorisation. It is a post hoc controlDefinition: post hoc control research method A control added after the first results were seen. It can test an explanation but carries less weight than a control fixed in advance, because the choice of control could follow the result. Excludes controls named in the preregistration. full definition: it can test an explanation, and it carries less weight than a control fixed in advance.

Data and provenance

  • The English Universal Declaration of Human Rights, 10,637 characters after runs of whitespace were collapsed, from the udhr2 collection of translations distributed with NLTK [7]. The download's source address was not recorded and the archive carries no licence file, so its licence is not established. We report numbers only and release no text from it.
  • Lewis Carroll, Alice's Adventures in Wonderland, characters 5,000 to 35,000, from the Project Gutenberg selection distributed with NLTK [8]. Public domain in the United States.
  • The training text for PPM: the first 5,000,000 characters of the other books in that selection, with Alice and the King James Bible left out.
  • The unseen text: 30,000 characters of an unpublished research log of ours, written in October 2026. It is not released. Its SHA-256 is 2248f9fa40d14608bc9b2932af537caa0b548722e16499532413ca020952850c, so a later release can be checked against it.
  • SmolLM2-360M [4], Hub revision f8027fd0, and Qwen3-0.6B [5], Hub revision c1899de2, both Apache-2.0, downloaded from the Hugging Face Hub on 31 October 2026 as safetensors with no remote code. The SmolLM2 weight file is 723,674,912 bytes and the Qwen3 file 1,503,300,328 bytes.

SmolLM2's technical report appeared in February 2025 and Qwen3's in May 2025 [4] [5]. That the unseen text was written after both models were trained rests on those dates and on the log's own dates.

Methods

Code length under a language model

Each text is split into tokensDefinition: token natural language processing The unit a language model reads and predicts, a whole word, part of a word or a single character taken from a fixed vocabulary of tens of thousands of pieces. Excludes a character or a byte. full definition, the word pieces a model reads, with the model's own tokenizer. Every token ti is priced at minus log⁡2 of the probability the model gave it after the tokens before it. The ideal code lengthDefinition: ideal code length information theory The sum over a text of minus log2 of the probability the model gave to each symbol that came next. A real arithmetic coder comes within a few bits of it. Excludes a measured file size, and any cost of storing the model. full definition of a text of C characters and T tokens is

b=1C∑i−log⁡2p(ti|t1,...,ti−1)(1)

in bits per character, with the sum over tokens 2 to T. The first token is priced at log⁡2V bits for a vocabulary of V tokens: 49,152 for SmolLM2 and 151,936 for Qwen3. Long texts are read in windows of 512 tokens that advance by 256, so every token after the first window is predicted from at least 256 tokens of context. The models ran in half precision on one GPU. Decoding the tokens gave back the exact original text for the declaration and Alice under both tokenizers.

A real code

An ideal length is only a claim until a coder achieves it. For each model, an arithmetic encoder turned the first 120 tokens of the declaration into a bit string, using a 64-token context, single precision weights on the CPU and probabilities rounded to integer frequencies out of 224. The decoder, given the bit string, the first token and the same model, rebuilt the 120 tokens. This is the kill condition in the design.

Classical coders

xzDefinition: xz data compression software A general-purpose file compressor using the LZMA method, which replaces repeated strings with references to earlier copies. Here at its strongest preset. Excludes any model of language beyond repeated byte strings. full definition is a general-purpose compressor that replaces repeated strings with references to earlier copies; it ran at its strongest preset, and its size in bits is divided by the number of characters. PPMDefinition: PPM data compression Prediction by partial matching, a compressor that predicts each character from counts of what followed the same preceding characters, falling back to shorter contexts when a longer one has not been seen. Here method C with exclusion and contexts of up to 5 characters. Excludes models with learned weights, such as neural language models. full definition, prediction by partial matching [6], predicts each character from counts of what followed the same preceding characters, here up to 5 characters back, with method C escapes and exclusion. A character never seen in any context costs log⁡2 of the number of Unicode code points. PPM cold starts empty and learns as it codes. PPM trained starts from counts over the 5,000,000 training characters and keeps learning as it codes; the counts are restored after each text.

Payback length

A compressor that must be sent along with the message pays for its own size. The payback lengthDefinition: payback length our usage, after the two-part code of minimum description length The number of characters a model must compress before the bits it saves over another compressor add up to the size of the model itself, when the model has to be sent along with the message. Excludes a compression ratio on one text, which ignores the cost of the model. full definition is the number of characters after which the bits saved over xz equal the model's size in bits:

N=8Sbxz−bm(2)

where S is the model's size in bytes and bxz and bm are bits per character under xz and under the model. For trained PPM, S is the training text compressed with xz, 1,458,524 bytes.

Cost of a known answer

For a prompt such as "The capital of Norway is" or "5 + 6 =", the cost of an answer is the code length of the answer's tokens given the prompt. Each prompt has a right answer and a wrong one. There are 20 capital-city prompts and 30 each of one-digit and three-digit sums.

Controls and planted checks

A controlDefinition: control statistics and experimental design A version of the data with the structure under test removed (for example shuffled or pooled), scored the same way as the real data, so the real score has something to beat. Excludes a comparison with a different dataset or with a published number. full definition is a version of the data with the structure under test removed and scored the same way. Three serve here.

Chart 1. Does PPM's training gain come from the order of the training text? Yes: training takes PPM from 2.57 to 1.99 bits per character on the declaration; training on the same characters shuffled gives 3.59, worse than no training, and on shuffled words 2.10.
Untrained
2.57
Trained on the books as written
1.99
Trained with every word shuffled
2.10
Trained with every character shuffled
3.59

bits per character on the declaration (lower is better)

  • untrained, 2.57
n
5,000,000 training characters; scored on the 10,637 characters of the declaration; one run per training set
Units
bits per character (the average number of bits a coder needs to store one character; lower is better compression). PPM (prediction by partial matching) is a classical coder that predicts each character from the few before it
Interval
Each value is one training run scored once. The result file holds no interval.
Baseline or control
Untrained PPM: 2.57 bits per character
Set in advance
Character shuffling must remove at least 0.8 of the training gain, set in advance: held, it removed 2.74 times the gain. Word shuffling removed 0.20 of it.
Supports
claim 4
Data behind chart 1 4 rows
PPM trainingDeclarationAlice in Wonderland
Untrained2.5732.839
Trained on the books as written1.9852.138
Trained with every word shuffled2.1032.395
Trained with every character shuffled3.5953.893

Read from t5_ppm.json. SHA-256 of the run's file 8e6f441fb47d3eb9ede14dfd3b312bff0b44725134b4a498cba53ef42710a0d3, published unchanged.

Read from score.json. SHA-256 of the run's file 96b08d26e027bd325055b13f817ad168e045d6159228007d9a4a9fef6ddd24b2, published unchanged.

The round trip of the methods section is a check that the model rows are real codes. An arithmetic encoder and decoder round-tripped a 120-token passage exactly with both models. The kill condition did not fire. The long-document figures remain ideal code lengths.

Chart 2. Are the model rows real codes that decode back to the text? Yes: a 120-token passage was coded into 306 bits by SmolLM2 and 444 bits by Qwen3, and the decoder returned the same tokens and the same text both times.
CheckDecoder outputRequiredResult
SmolLM2-360M: 120 tokens coded into 306 bits, token sequence after decodingidenticalidentical to the tokens encodedheld
SmolLM2-360M: the 614 characters of text after decodingidenticalidentical to the passageheld
Qwen3-0.6B: 120 tokens coded into 444 bits, token sequence after decodingidenticalidentical to the tokens encodedheld
Qwen3-0.6B: the 618 characters of text after decodingidenticalidentical to the passageheld
n
one passage of 120 tokens per model (614 and 618 characters)
Units
each row compares the decoder's output with the input of an arithmetic coder (a coder that turns a model's predicted probabilities into a string of bits)
Interval
Each row is an exact comparison of one decoded passage with its input.
Baseline or control
The long-document values in the other charts are ideal code lengths summed from the model's probabilities, not coded bit strings
Set in advance
An inexact round trip would have voided the model rows, set in advance. It did not happen.
Supports
claim 5
Data behind chart 2 4 rows
CheckDecoder outputRequiredResult
SmolLM2-360M: 120 tokens coded into 306 bits, token sequence after decodingidenticalidentical to the tokens encodedheld
SmolLM2-360M: the 614 characters of text after decodingidenticalidentical to the passageheld
Qwen3-0.6B: 120 tokens coded into 444 bits, token sequence after decodingidenticalidentical to the tokens encodedheld
Qwen3-0.6B: the 618 characters of text after decodingidenticalidentical to the passageheld

Read from t5_llm.json. SHA-256 of the run's file 74a522e61c75dd0450a8fdb2961a332e9ab4fd8ee0c97e8fdcad775546b718bd, published unchanged.

Read from score.json. SHA-256 of the run's file 96b08d26e027bd325055b13f817ad168e045d6159228007d9a4a9fef6ddd24b2, published unchanged.

PPM was retrained on the same 5,000,000 characters with every character shuffled, and again with every word shuffled. On the declaration, character-shuffled training gave 3.59 bits per character, worse than cold PPM at 2.57, so the trained model's gain over cold is gone and more. Word-shuffled training gave 2.10 against 1.99 for normal training, a loss of a fifth of the gain. The context model gains from letter order inside words much more than from word order, as it should.

The unseen text is the control for prior exposure. A coder that has seen nothing, cold PPM, gives a measure of how hard each text is in itself.

Results

Table 1 gives every coder on every text, and Figure 1 draws the same numbers.

SmolLM2 encodes the English Universal Declaration of Human Rights at 0.27 bits per character, and Qwen3-0.6B at 0.57. Against xz on the same text that is a tenfold and a fivefold lead. Our forecasts were 1.2 and 1.0, and both failed by far more than the 25 percent allowed. The Gutenberg book shows the same pattern more weakly: 0.89 under SmolLM2, against a forecast of 2.0.

Chart 3. What each coder needs per character on three texts. On the declaration the two language models need 0.27 and 0.57 bits per character against 2.83 for xz; on unseen text they need 1.59 and 1.66, and trained PPM (2.89) does worse than untrained PPM (2.70).
English declaration of human rights, 10,637 characters
xz
2.83; forecast 3.0, held
PPM, untrained
2.57; forecast 2.4, held
PPM, trained
1.99; forecast 2.1, held
SmolLM2-360M
0.27; forecast 1.2, failed
Qwen3-0.6B
0.57; forecast 1.0, failed
Unseen text written after the models were released, 30,000 characters
xz
2.74
PPM, untrained
2.70
PPM, trained
2.89
SmolLM2-360M
1.59
Qwen3-0.6B
1.66
Alice in Wonderland, 30,000 characters
xz
3.12; forecast 2.9, held
PPM, untrained
2.84
PPM, trained
2.14; forecast 2.1, held
SmolLM2-360M
0.89; forecast 2.0, failed
Qwen3-0.6B
1.16

bits per character (lower is better)

  • the declaration
  • unseen text
  • Alice in Wonderland
n
English declaration of human rights, 10,637 characters; Unseen text written after the models were released, 30,000 characters; Alice in Wonderland, 30,000 characters; each coder run once on each text
Units
bits per character (the average number of bits a coder needs to store one character; lower is better compression). A language model is used as a coder by turning its next-token probabilities into bits
Interval
Each value is one coder run once on one text. The result files hold no interval.
Baseline or control
xz and untrained PPM have seen no text before the one they code
Set in advance
Forecasts set in advance had to land within 25 percent: 5 of 8 held, and all 3 that failed are language-model rows that came in far lower than forecast. The unseen text was added after the forecasts.
Supports
claim 1, claim 4
Data behind chart 3 5 rows
CoderDeclarationUnseen textAlice in Wonderland
xz (a general file compressor)2.8342.7393.117
PPM, untrained (predicts each character from the few before it)2.5732.7032.839
PPM trained on 5 million characters of old books1.9852.8872.138
SmolLM2-360M (language model)0.2681.5920.889
Qwen3-0.6B (language model)0.5711.6581.163

Read from t5_ppm.json. SHA-256 of the run's file 8e6f441fb47d3eb9ede14dfd3b312bff0b44725134b4a498cba53ef42710a0d3, published unchanged.

Read from t5_llm.json. SHA-256 of the run's file 74a522e61c75dd0450a8fdb2961a332e9ab4fd8ee0c97e8fdcad775546b718bd, published unchanged.

Read from t5_fresh.json. SHA-256 of the run's file 677a2ecf1621c85ceaf3ffce81a7ca392302caf299fcf28a45e0f4db64b5ea3b, published unchanged.

Read from score.json. SHA-256 of the run's file 96b08d26e027bd325055b13f817ad168e045d6159228007d9a4a9fef6ddd24b2, published unchanged.

Chart 4. What it costs to send a right answer and a wrong one, given the question. A right capital city costs about 1 bit and a wrong one 18.3 to 19.5; a right three-digit sum still costs 8.5 to 9.1 bits, so the models recall capitals and do not reliably add.
Capital cities
SmolLM2-360M
right 0.98; wrong 19.47; right is cheaper in 20 of 20
Qwen3-0.6B
right 0.95; wrong 18.28; right is cheaper in 20 of 20
One-digit sums
SmolLM2-360M
right 4.01; wrong 4.63; right is cheaper in 24 of 30
Qwen3-0.6B
right 1.29; wrong 6.57; right is cheaper in 28 of 30
Three-digit sums
SmolLM2-360M
right 8.51; wrong 13.34; right is cheaper in 28 of 30
Qwen3-0.6B
right 9.11; wrong 13.83; right is cheaper in 29 of 30

bits to send the answer (fewer means more expected)

  • right answer
  • wrong answer
n
Capital cities: 20 prompts; One-digit sums: 30 prompts; Three-digit sums: 30 prompts; one right and one wrong answer per prompt
Units
mean code length in bits of the answer given its prompt (the bits the model needs to store the answer; fewer bits means the model expected it more)
Interval
Each value is a mean over the prompts of one task. The result file holds every prompt's bits and no interval.
Baseline or control
A model that knows the answer needs close to 0 bits for it
Set in advance
Set in advance for Qwen3: a right three-digit sum costs at least 10 bits. Failed, 9.11
Supports
claim 1
Data behind chart 4 6 rows
TaskModelRight answer, mean bitsWrong answer, mean bitsPrompts where right is cheaperPrompts
Capital citiesSmolLM2-360M0.97919.4712020
Capital citiesQwen3-0.6B0.95018.2752020
One-digit sumsSmolLM2-360M4.0104.6282430
One-digit sumsQwen3-0.6B1.2936.5672830
Three-digit sumsSmolLM2-360M8.50713.3412830
Three-digit sumsQwen3-0.6B9.11413.8332930

Read from t5_llm.json. SHA-256 of the run's file 74a522e61c75dd0450a8fdb2961a332e9ab4fd8ee0c97e8fdcad775546b718bd, published unchanged.

Read from score.json. SHA-256 of the run's file 96b08d26e027bd325055b13f817ad168e045d6159228007d9a4a9fef6ddd24b2, published unchanged.

On text written after their training, the two models need 1.59 and 1.66 bits per character. SmolLM2 needs about six times the bits it needs on the declaration. Its lead over xz falls from tenfold to under twofold.

Chart 5. From a text the models may have seen to one they cannot have seen. SmolLM2 goes from 0.27 to 1.59 bits per character, 5.9 times as many, while untrained PPM moves only from 2.57 to 2.70: the unseen text is about as hard in itself.
xz
2.83 to 2.74; 0.97 times
PPM, untrained
2.57 to 2.70; 1.05 times
PPM, trained
1.99 to 2.89; 1.45 times
SmolLM2-360M
0.27 to 1.59; 5.94 times
Qwen3-0.6B
0.57 to 1.66; 2.90 times

bits per character (lower is better)

  • the declaration
  • unseen text
n
10,637 characters of the declaration and 30,000 characters of unseen text; each coder run once on each
Units
bits per character (the average number of bits a coder needs to store one character; lower is better compression)
Interval
Each value is one coder run once on one text. The result files hold no interval.
Baseline or control
Untrained PPM has seen nothing, so its two values measure how hard each text is in itself: 2.57 and 2.70
Set in advance
None set in advance. The unseen text is a control added after the forecasts were fixed.
Supports
claim 2, claim 3
Data behind chart 5 5 rows
CoderDeclarationUnseen textUnseen over declaration
xz (a general file compressor)2.8342.7390.97
PPM, untrained (predicts each character from the few before it)2.5732.7031.05
PPM trained on 5 million characters of old books1.9852.8871.45
SmolLM2-360M (language model)0.2681.5925.94
Qwen3-0.6B (language model)0.5711.6582.90

Read from t5_ppm.json. SHA-256 of the run's file 8e6f441fb47d3eb9ede14dfd3b312bff0b44725134b4a498cba53ef42710a0d3, published unchanged.

Read from t5_llm.json. SHA-256 of the run's file 74a522e61c75dd0450a8fdb2961a332e9ab4fd8ee0c97e8fdcad775546b718bd, published unchanged.

Read from t5_fresh.json. SHA-256 of the run's file 677a2ecf1621c85ceaf3ffce81a7ca392302caf299fcf28a45e0f4db64b5ea3b, published unchanged.

Cold PPM, which has seen nothing, finds the unseen text only slightly harder than the declaration: 2.70 against 2.57 bits per character. xz finds it easier, 2.74 against 2.83. A sixfold jump for a language model on a text that classical coders find about as hard as the declaration points at prior exposure to the declaration.

Trained PPM does worse than cold PPM on the unseen text, 2.89 against 2.70 bits per character. Its training on literary English helps on the declaration and on Alice and hurts on our technical writing.

c4 observed, evidence for claim 4
The numbers in claim 4
2.89; 2.70 matches the result file, 2026-11-09
Chart 1
Does PPM's training gain come from the order of the training text?
Chart 3
What each coder needs per character on three texts.
Basis
observed: measured in this study, with a result file

Model size changes the ranking for short messages. By eq. 2, SmolLM2 pays for its 723,674,912 bytes against xz after 2.6 billion characters of Alice-like text, which held the preregistered bound of at least one billion. On the unseen text, where its lead over xz is 1.15 bits per character, the same arithmetic gives about 5 billion characters. Trained PPM pays back after 11.9 million characters of Alice-like text.

Figure 2 shows the cost of sending a known answer. A right capital city costs about 1 bit under either model, and a wrong one 18 to 20. A one-digit sum costs Qwen3 1.29 bits and SmolLM2 4.01, close to its 4.63 for a wrong sum. A three-digit sum costs 8.5 to 9.1 bits even when right, and a wrong one costs only about 5 bits more. The answer costs fit recall of capital cities and show no sign of reliable three-digit addition.

Appendix A sets every preregistered forecast for this part against its outcome.

Discussion

The headline number, 0.27 bits per character, is true of the declaration and says little about language. The declaration is copied widely on the public web, so we infer that it sits in the training data of both models, probably many times; we did not check their training sets. A model that has seen it often can code it from recall. The unseen text removes that route, and the lead over classical coders drops to what a model of language buys.

That residual lead is still real. On text neither model could have seen, both need about 1.6 bits per character against 2.70 to 2.89 for the classical coders. This agrees with the main claim of Delétang and colleagues [1] that language models are strong compressors, and with their point that the model's size belongs in the count: on fresh text, SmolLM2 needs billions of characters before it pays for itself against xz.

Our result fits the evaluation design of Li and colleagues [3], who score compression on text from after each model's training cutoff. It also bears on compression used as a measure of capability [2]. A corpus that overlaps the training data rewards recall, and two models can rank differently on recall than on language. Here the smaller model, SmolLM2, leads by a factor of two on the declaration and by 4 percent on the unseen text.

The trained PPM result is a smaller lesson of the same kind. Counts from Gutenberg books help on literary text and hurt on a technical log. A compressor's training text is part of its result, for a context model as much as for a neural one.

Limitations

  • There is one unseen text. It is our own technical writing in one register, full of numbers and technical terms, and it was chosen after the headline numbers were seen. A set of fresh texts across registers is needed before the size of the memorisation share can be stated.
  • The unseen text differs from the declaration in style as well as in novelty. Cold PPM finds the two about equally hard, which suggests the difficulty gap is small, but it does not remove the difference.
  • That the unseen text was written after the models were trained rests on its date. We have not checked whether it quotes public text.
  • The unseen text is not released, so no one else can rerun that row. Its hash is given so a later release can be checked.
  • Both models are small, 360 million and 600 million parameters. Larger models may memorise more.
  • The round trip covered 120 tokens. The long-document figures are ideal code lengths, and a real coder would add a few bits.
  • All declaration and Alice rows for the language models carry the same contamination.
  • The licence of the declaration file is not established; we report numbers only.
  • Scoring was done by our own code and was not blind.

Evidence

Held. Changes how to read common LLM compression numbers; needs a wider unseen set.

Figures

These are the paper's own figures, numbered as in the PDF, and each "Figure" reference in the text points here. The charts on this page redraw the same results from the result files and carry their own numbers.

Grouped bars of bits per character for five coders on three texts, the language models lowest on every text and far lowest on the declaration
Figure 1. Bits per character for each coder on the three texts. The language models' lead over the classical coders is largest on the declaration and smallest on the unseen text. Drawn from the study's result files.
Grouped bars of the mean bits to send right and wrong answers for capital cities, one-digit sums and three-digit sums under both models
Figure 2. Mean code length of a right and a wrong answer given its prompt, for each model and task. Drawn from the study's result file.

Tables

Table 1. Bits per character for each coder and text. Lower is better. The unseen text is a post hoc control.
TextxzPPM coldPPM trainedSmolLM2-360MQwen3-0.6B
English declaration, 10,637 characters2.832.571.990.270.57
Alice, Gutenberg, 30,000 characters3.122.842.140.891.16
Unseen, October 2026, 30,000 characters2.742.702.891.591.66

Appendix A. The preregistered forecasts

Each verdictDefinition: verdict research method (our usage) The pass or fail of one preregistered rule set against the run's numbers, read off by code. Excludes an interpretation written after reading the numbers. full definition is the pass or fail of a rule written before the run, read off by code. A point forecast holds within 25 percent of its value. Values are read from the study's score file. The unseen-text control has no forecast and is not listed.

Table 2. Preregistered forecasts for the compression part of the study and their outcomes.
ForecastRuleMeasuredHolds
xz on the declaration3.02.83yes
PPM cold on the declaration2.42.57yes
PPM trained on the declaration2.11.99yes
SmolLM2 on the declaration1.20.27no
Qwen3 on the declaration1.00.57no
xz on Alice2.93.12yes
PPM trained on Alice2.12.14yes
SmolLM2 on Alice2.00.89no
SmolLM2 above cold PPM, of 9 other translationsat least 30no
Qwen3 below cold PPM, of 9 other translationsat least 68yes
SmolLM2 payback against xz, charactersat least 1 billion2.6 billionyes
Trained PPM payback against xz, charactersat most 200 million11.9 millionyes
Arithmetic round trip exactyes, both modelsyes, bothyes
Capital city, bits, Qwen3at most 40.95yes
One-digit sum, bits, Qwen3at most 41.29yes
Three-digit sum, bits, Qwen3at least 109.11no
Wrong minus right answer, bits, Qwen3at least 108.08no
PPM trained on Gutenberg, cheapest task mean, bitsat least 2020.4yes
PPM with a stored answer table, stored answers, bitsat most 211.2no
PPM with a stored answer table, unseen answers, bitsat least 154.9no
Share of trained PPM gain removed by shuffled charactersat least 0.82.74yes

The answer forecasts are scored on Qwen3 because the scoring code picks the model with the lower cost on capital cities. The two rows on other translations compare each model with cold PPM on nine non-English translations of the declaration, which carry the same contamination as the English rows. The stored-table test did not separate lookup from computation as forecast. A gain share above 1 means the shuffled training made PPM worse than starting cold.

What lowers it

  • scoring Scored by code and by the agent that ran it; self-graded. from our publication register, on who scored it
  • blinding Not blind, as the paper's limitations state. from the paper's Limitations
  • depth of reading The cited literature was read at the level of abstracts, publisher pages and repository pages; full texts were not read. from the Verified section

What holds it up

  • preregistration Preregistered and hash-locked before the run (sha256 568a182b). from the Reproduce section

Where the claim stands

Our register assigns this finding no rung on the ladder. Its entry describes the study as: post hoc control on a preregistered study.

Trail

Versions

  1. v3 2026-11-14, this page corrected, 1 item; the PDF and its BuildTeX source are still paper version 1.0
  2. v2 2026-11-09, paper version 1.0, first published PDF sha256 2551ac61b645b010
  3. v1 2026-11-01, entered in the findings ledger

Corrections

  1. 2026-11-14 wording found by a review of the published pages

    A review of the published page found the summary stating a size the paper's own limitations say cannot yet be stated. now The summary and the abstract said most of the advantage on the declaration comes from the model having seen it; with one fresh text of 30,000 characters the page can say the result points at prior exposure, and both now say that. The title said bits a letter; the unit is bits per character, which counts spaces and punctuation.

  2. 2026-11-01 wording found by the study itself, before publication

    The unseen-text control was added after the first results were seen and is labelled post hoc wherever it appears.

Each correction is a dated note; the findings ledger is never rewritten, and a note governs where it differs.

Ledger and version dates up to publication are local dates in US Pacific time. Clock times in the text are UTC, seven or eight hours ahead, so a lock or a run stamped just after midnight UTC belongs to the previous local day. Corrections from 14 November 2026 on are dated in UTC.

References

  1. Deletang, G., Ruoss, A., Duquenne, P.-A., Catt, E., Genewein, T., Mattern, C., Grau-Moya, J., Wenliang, L. K., Aitchison, M., Orseau, L., Hutter, M. and Veness, J. (2024). Language modeling is compression. International Conference on Learning Representations (ICLR 2024). arXiv:2309.10668 abstract or summary, 2026-11-09: abstracts, publisher pages and repository pages; full text not read used in Introduction, Discussion
  2. Huang, Y., Zhang, J., Shan, Z. and He, J. (2024). Compression represents intelligence linearly. arXiv:2404.09937 abstract or summary, 2026-11-09: abstracts, publisher pages and repository pages; full text not read used in Introduction, Discussion
  3. Li, Y., Guo, Y., Guerin, F. and Lin, C. (2024). Evaluating large language models for generalization and robustness via data compression. arXiv:2402.00861 abstract or summary, 2026-11-09: abstracts, publisher pages and repository pages; full text not read used in Introduction, Discussion
  4. Ben Allal, L., Lozhkov, A., Bakouch, E. and others (2025). SmolLM2: when smol goes big, data-centric training of a small language model. arXiv:2502.02737. Model: https://huggingface.co/HuggingFaceTB/SmolLM2-360M, Apache-2.0. run here Licence: as stated in the paper's data section used in Data and provenance, Data and provenance
  5. Qwen Team (2025). Qwen3 technical report. arXiv:2505.09388. Model: https://huggingface.co/Qwen/Qwen3-0.6B, Apache-2.0. run here Licence: as stated in the paper's data section used in Data and provenance, Data and provenance
  6. Cleary, J. G. and Witten, I. H. (1984). Data compression using adaptive coding and partial string matching. IEEE Transactions on Communications 32(4), 396-402. doi:10.1109/TCOM.1984.1096090 abstract or summary, 2026-11-09: abstracts, publisher pages and repository pages; full text not read used in Methods
  7. United Nations (1948). Universal Declaration of Human Rights, English text and translations as distributed in the NLTK udhr2 corpus. Source address of the download not recorded; licence not established. run here Licence: as stated in the paper's data section used in Data and provenance
  8. Project Gutenberg texts as distributed in the NLTK Gutenberg selection. https://www.gutenberg.org. Public domain in the United States. run here Licence: as stated in the paper's data section used in Data and provenance

Cited by later findings

  • No later record in the findings ledger treats this finding.

Reproduce

Data

Preregistration

sha256 568a182b71d3b95a6414c3ff7f72af999cc0f483658f17580acebc9aac738e90
plan e37b7bbefb8d5b9b98055a5352ed5fa3f467a29a157dda5129ad02a80dd9434d

Steps

  1. Data: the English declaration from the NLTK udhr2 collection; Alice from the NLTK Gutenberg selection, characters 5,000 to 35,000; any English text you can show was written after the models were released, in place of our unreleased log.
  2. Download SmolLM2-360M and Qwen3-0.6B from the Hugging Face Hub at the revisions given in the data section.
  3. For each text, compute eq. 1 with windows of 512 tokens advancing by 256.
  4. Confirm with an arithmetic coder that a short passage decodes back to the same tokens.
  5. Compare with xz at its strongest preset and with PPM-C of order 5 with exclusion, cold and trained on 5 million characters of other Gutenberg books.
  6. Preregistration SHA-256: 568a182b71d3b95a6414c3ff7f72af999cc0f483658f17580acebc9aac738e90. Plan SHA-256: e37b7bbefb8d5b9b98055a5352ed5fa3f467a29a157dda5129ad02a80dd9434d. Scored run 20261101T091251Z.

Cost. The model measurements on the declaration, Alice and the answers took 426 seconds on one GPU; the unseen-text run was not timed. The PPM and xz rows run on one desktop CPU. The study was not re-run.

Downloads

The PDF is typeset by BuildTeX from F515.bld, which is written from the same source as this page. The receipt records the source's SHA-256 and the PDF's (2551ac61b645), so anyone can rebuild it and compare. The copy here has its hidden author field blanked, as the site does for every file it publishes; blank the same field in a rebuild before comparing. The name stays on the first page.

Verified

Verified on 2026-11-09. On 9 November 2026 every bits-per-character value in Table 1, the character counts 10,637 and 30,000, the token counts, the vocabularies, both model file sizes, the round trip on 120 tokens for both models, the answer costs, the shuffled-training values, the trained PPM model size, both preregistered payback values and every forecast in Appendix A were re-read from the study's result files and its score file. They match the findings ledger. The forecast file's SHA-256 was recomputed and matches the hash recorded beside it and in the study's lock. The unseen-text SHA-256 is the one recorded in its result file. The payback of about 5 billion characters on the unseen text is our arithmetic by eq. 2 from the recorded model size and the two rates. Both figures were drawn by a script that reads only the result files.

Not checked. The study was not re-run. The literature in the introduction was found by searches run on 9 November 2026 and read at the level of abstracts, publisher pages and repository pages; the full texts of the cited papers were not read for this paper.

Terms on this page

Each term is defined where it is first used on this page. Each name below opens its entry in the findings glossary, which lists every page that uses it.

To report an error, name the finding, the claim number and the source on the Work page, which gives the address. Accepted corrections join the Trail with their date.