Predict how cl100k_base tokenizes '1024', '2048', and '100000', and explain how inconsistent splitting causes LLM arithmetic failures.

In cl100k_base, the tokenizer used by recent OpenAI models, numbers are split into chunks of at most three digits. So `1024` becomes `102` plus `4`, `2048` becomes `204` plus `8`, and `100000` becomes `100` plus `000`. Even short-looking numbers split once they exceed three digits. The reason this breaks arithmetic is that the model only ever sees these chunks, never the individual digits. To add two numbers correctly you line up ones, tens, and hundreds and carry between them. But the tokenizer splits numbers at three-digit boundaries, not along those place-value lines. So when the model sees 1024 as the chunks 102 and 4, it has no clean access to the 1, the 0, the 2, and the 4 as separate place-valued quantities. It cannot run the digit by digit procedure you learned in school. Instead it falls back on patterns memorized from training, which works for famous sums and fails for arbitrary ones.

The trap is assuming the model adds digit by digit. It does not, because cl100k_base never hands it single digits for multi-digit numbers. Here is the **prediction**. cl100k_base caps numeric runs at three digits, so `1024` is `['102', '4']`, `2048` is `['204', '8']`, and `100000` is `['100', '000']`. Every number longer than three digits splits, and the split point follows the three-digit grouping rule, not place value. That mismatch is the whole problem. Correct addition needs a stable atomic unit, the single digit, so you can align ones with ones and propagate carries. The encoding cl100k gives the model multi-digit chunks instead. The chunk `102` from `1024` carries no addressable internal 1, 0, 2 the model can align. The chunking is also misaligned with the operands you actually add. `1024` is `['102', '4']` while `1025` is `['102', '5']`. The model sees a shared `102` chunk and a varying final digit rather than four positioned digits. A pattern keyed to one chunk sequence does not generalize to a number whose chunking differs. The model ends up memorizing famous results rather than computing, which is why it nails 2 + 2 and stumbles on 471 + 829. The mitigation is to offload exact math to a code interpreter or to space out digits.