Pith. sign in

REVIEW 3 major objections 6 minor 2 cited by

Tokenization Constraints in LLMs: A Study of Symbolic and Arithmetic Reasoning Limits

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Matching token boundaries to the atomic units of a task, such as one letter per token, can improve LLM accuracy on symbolic reasoning by tens of percentage points and may matter more than model size.

desk verdict Solid, reproducible formatting effect with a real confound: the BPE-causal claim needs a same-format, different-tokenizer condition. read the letter →

arxiv 2505.14178 v1 pith:A2SFIPNY submitted 2025-05-20 cs.CL cs.AI

Xiang Zhang , Juntai Cao , Jiaqi Wei , Yiwei Xu , Chenyu You This is my paper · ORCID
classification cs.CLcs.AI
keywords reasoningsymbolicmodelscomputationtokentokenizationarithmeticllms
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Language models do not read text one letter at a time. They use a tokenizer that merges characters into chunks, so the string 'abaa' might become one token. This paper tests what happens when those chunks hide the letters you need to count.

The authors gave models a simple task, counting how many 'a' appear in a random string of 'a' and 'b', and fed the same task in four formats: the raw string, a string with spaces between letters, a comma-separated list, and a list of quoted single letters. The task is identical in all four, but the tokenization is very different.

Results showed large swings. With a raw BPE string, GPT-4o-mini counted correctly under 10% of the time for longer strings, even when told to think step by step. With a fully separated format, accuracy jumped to roughly 70-90%. The same pattern held for sorting and reversing characters, and a rare letter like 'z' was counted more accurately than a common letter like 'e', suggesting that token embeddings carry competing information.

The paper also reports that a small model with good tokenization beat OpenAI's o1 model on a 30-40 character counting task. However, that comparison is not apples-to-apples: o1 received only the raw string format, while the small model got the friendly format and a supervised reasoning prompt.

Extended reading notes

Core claim

The paper's central assertion is that 'token structure dramatically affect[s] reasoning performance, causing failure even with CoT, while atomically-aligned formats unlock strong generalization' (Abstract). Concretely, it claims that BPE merging characters into tokens hides atomic reasoning units, and that re-formatting inputs so each unit is its own token (format type d) improves counting accuracy by up to 80.6 percentage points for GPT-4o-mini (Table 1) and lets GPT-4o-mini beat OpenAI o1 on 30-40 length letter counting (70.7% vs 50%, Tables 1 and Appendix E.1).

Load-bearing premise

The causal attribution rests on the assumption that formats (a)-(d) hold task difficulty fixed: 'changing the format does not alter the fundamental nature or difficulty of the counting task' (Figure 3 caption). If a comma-separated list or quoted-item list is intrinsically easier for an LLM than a raw string, independent of tokenization, then the observed accuracy gap is not evidence that BPE hides information, only that some surface forms are easier. This assumption enters in Section 5.5 ('the underlying symbolic task fixed') and Section 6.1 ('task identity remains unchanged across formatting conditions').

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 6 minor

Summary. The paper argues that BPE tokenization constrains chain-of-thought symbolic reasoning by merging or hiding atomic reasoning units. It introduces two formal notions, Token Awareness and CoT Fidelity (Sections 5.2 and 5.3), defines a tokenization damage measure Delta_tok (Section 5.5), and reports experiments on letter counting (Tables 1 and 2), sorting (Table 3), and reversing (Table 4) across four input formats labeled (a) through (d). The central empirical claims are that atomic-aligned format (d) improves counting accuracy by up to 80.6 percentage points for GPT-4o-mini, that error patterns under BPE are systematic undercounts (Section 6.3), and that GPT-4o-mini with format (d) and CoT outperforms OpenAI o1 on 30-40 length letter counting (Appendix E.1 vs Tables 1 and 2).

Significance. If the causal claim were established, the paper would be a practically significant contribution: it would show that tokenizer design is not a neutral preprocessing step but a first-order determinant of symbolic reasoning performance, with concrete implications for model deployment and tokenizer design. The study has clear strengths: 1000 instances per experimental cell, three API models, consistency across counting, sorting, and reversing, public release of per-instance results, and a reported replication variance below 1% (Appendix F). These properties make the headline accuracy gaps unlikely to be mere noise. However, the central causal attribution is not yet established because no experiment varies tokenization while holding the visible input format fixed. The task-difficulty confound identified in the review is real and load-bearing, and the o1 comparison is unmatched. With additional controlled experiments, the paper could become a solid empirical contribution; in its current form the main conclusion is supported less strongly than the Abstract claims.

major comments (3)
  1. [§5.5, Fig. 3, §6.1] The central causal claim that BPE token merging, rather than surface format, explains the accuracy gaps is not tested. Formats (a)-(d) differ not only in token boundaries but also in visible syntax: (a) is a fused string, (b) is space-delimited, (c) is comma-delimited, and (d) is a quoted, comma-separated list. Counting items in an explicit list is plausibly easier for an LLM than counting characters inside a fused string, independent of tokenizer internals. The assertion in the Figure 3 caption and in Section 6.1 that changing the format does not alter task difficulty is an assumption, not a demonstrated result. No condition in the paper varies token boundaries while holding the visible string constant; Appendix C only shows that different models tokenize the formats differently. Consequently, Delta_tok in Tables 1-4 conflates tokenization effects with format difficulty. I request a control condition that holds the visible input fixed and varies only the tokenizer (for example, an open model with a character-level tokenizer versus a BPE tokenizer on identical strings, or a byte-level forced segmentation in an API setting), or a condition that manipulates visible difficulty while holding tokenization fixed.
  2. [Appendix E.1, Tables 1-2] The o1 comparison is not matched. In Appendix E.1, o1 is evaluated only on format (a) with a straightforward base prompt, while the GPT-4o-mini results it is compared against use format (d) with CoT prompting (and, in the supervised variants, a step-by-step counter instruction). The model identity, the prompt, and the input format are therefore jointly confounded. The conclusion in Appendix E.1 that inference-time scaling 'does not make up for defect in tokenizer' is not supported by this design. Please run o1 on format (d) with a comparable CoT prompt, and also report the number of o1 test instances and the variance of the 50% estimate. The headline comparison in the Abstract should be softened or removed until this is done.
  3. [§5.2, §5.3, §5.4] The theoretical apparatus in Sections 5.2-5.4 is not yet operational. TokenAwareness is defined as I[prop in Emb(t_i)], but the paper does not specify how one determines whether a property is recoverable from an embedding; the definition is therefore not connected to any observable measurement. Fidelity(CoT) is bounded by |phi(S_h) intersect S_o| / |S_h|, but the sets S_h, S_o, the mapping phi, and the notion of overlap are not defined with enough precision to support a derivation, and no theorem is stated. These sections read as post hoc naming conventions rather than a formalization that predicts the empirical results. If the theoretical framing is to be a contribution, it needs measurable definitions or a proof linking TokenAwareness and Fidelity to Delta_tok; otherwise Section 5 should be presented explicitly as intuition and framing, not as the formalization promised in the Abstract.
minor comments (6)
  1. [§6.1] The task list says 'Sorting and Sorting'; the second one should be 'Reversing', matching Tables 3 and 4.
  2. [Tables 1-2] The column headers spell 'deliminated'; this should be 'delimited'.
  3. [§5.5, Tables 1-4] The definition of Delta_tok in Section 5.5 is an expectation over atomic-aligned and merged-token inputs, but the tables report 'Delta_tok[max]'. Please clarify whether the tabulated quantity is the maximum over formats, the maximum over target letters, or something else, and define it consistently.
  4. [Figure 12 and Appendix D] The prompt template in Figure 12(c) contains the instruction 'Output your step-by-step counting process', and Figure 14(b) has a typo 'Conbine'; these should be fixed.
  5. [Appendix E.1] The text contains the typo 'accuray'; more substantively, the appendix does not state the number of o1 test instances or the variance of the reported 50% accuracy, which should be added.
  6. [§6.3] The error-shift analysis in Figure 4 is informative, but the claim that pure BPE yields 'exclusively negative' shifts is based on the displayed distribution; please report the exact counts or a confidence interval for the proportion of negative shifts.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the accuracy gaps are measured, not fitted, and the theoretical formalisms are definitions rather than derived predictions.

full rationale

The paper's empirical core is a measured comparison, not a fitted prediction. Delta_tok is defined as an accuracy gap between input formats and then computed on independently sampled instances; no parameter is optimized against the experimental outcomes, so the improvements in Tables 1, 2, 5, 6, and 8 are not forced by construction. The theoretical constructs Token Awareness and CoT Fidelity are formal definitions and a tautological overlap bound; the paper does not use them to generate the accuracy numbers, so they cannot serve as circular inputs to the central empirical claim. The main result is also self-contained in an important respect: the tokenization effect appears both with unsupervised CoT and with supervised CoT, so the citation to the authors' prior SCoT work (Zhang et al., 2025) is not load-bearing for the tokenization finding. Likewise, the CoT Turing-completeness framing cites the authors' prior work (Zhang et al., 2024) alongside independent work, but the observed formatting sensitivity does not reduce to that citation because the same ordering of formats is externally measurable against API models. The most serious concern, that formats (a)-(d) may differ in surface difficulty independent of token boundaries, is a validity/confound worry rather than circularity: the paper asserts in the Figure 3 caption and Sections 5.5 and 6.1 that task identity and difficulty are unchanged, but it never defines difficulty as model accuracy, so the claim is not true by construction. No step in the derivation chain is equivalent to its inputs by definition, and the limitations acknowledged by the authors (narrow model coverage, no extreme lengths) do not indicate circularity.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The paper introduces no fitted numeric parameters; its Delta_tok quantity is an average of accuracies. It relies on standard complexity-theoretic background (TC0, depth bounds) and on prior CoT-completeness results from its own authors. The 'Token Awareness' metric is a definition, not a fitted quantity, so it imposes no free parameters but also provides no independent predictive test.

assumptions (4)
  • standard math Answer-only Transformers are in TC0 and cannot compute parity, addition, or counting over unbounded inputs.
    Cited to Li et al. 2024a, Zhang et al. 2024, and Chang and Bisk 2024; used in Section 3 to motivate the need for CoT.
  • domain assumption CoT with unlimited token budget and perfect token-to-state fidelity makes autoregressive transformers Turing complete.
    Under 'ideal assumptions' in Section 4.2, cited to Zhang et al. 2024 and Li et al. 2024b; not proven in this paper.
  • domain assumption Tokenizers merge common substrings and delimiters, and adding repeated delimiters forces token boundaries.
    Assumed about modern BPE tokenizers in Section 5.5 and validated for GPT-4o, Claude, and Qwen in Appendix C.
  • domain assumption A model cannot access sub-token character properties, so if TokenAwareness(t_i, prop)=0, reasoning over prop fails.
    Core premise of Section 5.2; the empirical results are consistent with it but it is not directly measured at the embedding level.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Tokenization Constraints in LLMs: A Study of Symbolic and Arithmetic Reasoning Limits." pith.science (2026). https://pith.science/paper/A2SFIPNY

@misc{pith2026250514178,
  author       = {Pith},
  title        = {Pith review of: Tokenization Constraints in LLMs: A Study of Symbolic and Arithmetic Reasoning Limits},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/A2SFIPNY}},
  note         = {Machine review of arXiv:2505.14178}
}
read the original abstract

Tokenization is the first - and often underappreciated - layer of computation in language models. While Chain-of-Thought (CoT) prompting enables transformer models to approximate recurrent computation by externalizing intermediate steps, we show that the success of such reasoning is fundamentally bounded by the structure of tokenized inputs. This work presents a theoretical and empirical investigation into how tokenization schemes, particularly subword-based methods like byte-pair encoding (BPE), impede symbolic computation by merging or obscuring atomic reasoning units. We introduce the notion of Token Awareness to formalize how poor token granularity disrupts logical alignment and prevents models from generalizing symbolic procedures. Through systematic evaluation on arithmetic and symbolic tasks, we demonstrate that token structure dramatically affect reasoning performance, causing failure even with CoT, while atomically-aligned formats unlock strong generalization, allowing small models (e.g., GPT-4o-mini) to outperform larger systems (e.g., o1) in structured reasoning. Our findings reveal that symbolic reasoning ability in LLMs is not purely architectural, but deeply conditioned on token-level representations.

Figures

Figures reproduced from arXiv: 2505.14178 by the authors.

Figure 1
Figure 1. Illustration of inductive reasoning as performed by humans, RNNs, and LLMs with CoT, respectively. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. CoT vs Answer Only Generation Models. counting via bracket pairing tasks, leveraging gat￾ing and cell-state mechanisms to maintain multiple counters—capabilities that standard RNNs lacked. Theory of Model Architectures with Compos￾ability. Delétang et al. (2022) systematically inves￾tigated arithmetic capabilities across modern archi￾tectures, including RNNs, LSTMs, and Transform￾ers. Their findings confirmed that w… view at source ↗
Figure 3
Figure 3. Four types of string formatting to manipulate tokenization in counting. Examples in the figure are [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (11 more)
Figure 4
Figure 4. Figure 4: Distribution of shifts from the correct count. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Counting accuracy (Orange) with respect to [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: Tokenization patterns of the GPT-4o tokenizer [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Tokenization patterns of the GPT-4o tokenizer [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Pairwise comparison of counting accuracy [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: Same error-shifting distribution (as in Figure [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]
Figure 10
Figure 10. Figure 10: Difference in tokenization on long binary strings without punctuations across different LLMs. (a) string: abbab (b) string: a b b a b (c) string: a, b, b, a, b (d) string: “a”, “b”, “b”, “a”, “b” LLAMA Claude (a) string: abbab (b) string: a b b a b (c) string: a, b, b…
Figure 11
Figure 11. Figure 11: Difference in tokenization on binary strings when counting instances are presented in different formats with punctuations to facilitate tokenization, across different LLMs [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]
Figure 12
Figure 12. Figure 12: Different prompt templates used in counting experiments. The templates include a base prompt, an [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]
Figure 13
Figure 13. Figure 13: Different prompt templates used in reversing experiments. The templates include an unsupervised [PITH_FULL_IMAGE:figures/full_fig_p017_13.png]
Figure 14
Figure 14. Figure 14: Different prompt templates used in sorting experiments. The templates include an unsupervised chain-of [PITH_FULL_IMAGE:figures/full_fig_p018_14.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. The Effect of Scripts and Formats on LLM Numeracy

    cs.CL 2026-01 conditional novelty 6.0 of 10

    LLM arithmetic accuracy falls sharply when numerals leave the familiar Hindu–Arabic format, and few-shot prompting with examples narrows most of that gap.

  2. VisReason: A Large-Scale Dataset for Visual Chain-of-Thought Reasoning

    cs.CV 2025-11 conditional novelty 5.0 of 10

    Fine-tuning Qwen2.5-VL on VisReason, a 489K-example multi-round visual chain-of-thought dataset (165K with pseudo-depth), modestly improves LLM-judged visual reasoning scores, with caveats about self-referential 3D ev...

Reference graph

Works this paper leans on

18 extracted references · 15 canonical work pages · cited by 2 Pith papers

  1. [1]

    Table 20 shows that using a base prompt with standard BPE tokenization (type (a)) results in a counting error of 3 from the correct value

    work page

  2. [2]

    Table 21 demonstrates that incorporating su- pervised CoT improves accuracy, reducing the counting error to just 1

    work page

  3. [3]

    a” , “b” , “b

    Table 22 illustrates that combining supervised CoT with type (d) character-wise tokenization achieves perfect accuracy, matching the gold label exactly. These examples clearly demonstrate how the syn- ergy between CoT reasoning and appropriate to- kenization methods can progressively enhance counting accuracy. E.4 Claude 3.5 Sonnet We evaluate Claude 3.5 ...

    work page

  4. [4]

    End of string reached. Result: 12 Correct Answer: 13 Table 21: Case Study 9 - Incorrect Prediction with GPT 4o mini (CoT prompt) Model & Experiment: GPT-4o mini, token type (a), length 20-30 Prompt: Task: Count the number of occurrences of the substring ‘a’ in the given string step by step. Do not use bold font in the response. Instructions: • Iterate thr...

    work page

  5. [7]

    Initialize an empty string called ‘reversed’

    work page

  6. [8]

    For each character in the input string: • Remove the first (leftmost) character • Add this character to the beginning of ‘reversed’ • Display the remaining input string

    work page

  7. [9]

    Return the reversed string in a dictionary format with the key ‘Result’

    Once all characters are processed, ‘reversed’ will contain the reversed string. Return the reversed string in a dictionary format with the key ‘Result’. For example, the result dictionary for input string "hello" will be {‘Result’: ‘olleh’}. Input String: {{string}} (b) Chain-of-Thought (supervised) prompt template Figure 13: Different prompt templates us...

    work page

  8. [10]

    Start by creating an empty list for sorted characters

    work page

Show all 18 references
  1. [11]

    • Display both the original string (showing characters remaining) and sorted list after each step

    For each step: • Specify which character you’re currently looking and insert the character to the correct place in sorted list. • Display both the original string (showing characters remaining) and sorted list after each step

  2. [12]

    [‘2’, ‘C’, ‘s’, ‘U’, ‘4’, ‘b’, ‘S’, ‘c’]

    Conbine the sorted list to a single string. Return the sorted string in a dictionary format with the key ‘Result’. For example, the result dictionary for input list “[‘2’, ‘C’, ‘s’, ‘U’, ‘4’, ‘b’, ‘S’, ‘c’]” will be {‘Result’: ‘24CSUbcs’}. String: {{string}} (b) Chain-of-Thoug...

  3. [13]

    Start with the string: abaaababbbbbbaaaabaaaa

  4. [15]

    Iterate through each character in the string. - Index 0: ’a’ (counter = 1) - Index 1: ’b’ (counter remains 1) - Index 2: ’a’ (counter = 2) - Index 3: ’a’ (counter = 3) - Index 4: ’a’ (counter = 4) - Index 5: ’b’ (counter remains 4) - Index 6: ’a’ (counter = 5) - Index 7: ’b’ (...

  5. [17]

    Initialize a counter at 0

  6. [18]

    - Index 0: The element is ‘a’

    Start iterating through the list: [‘a’, ‘b’, ‘a’, ‘a’, ‘a’, ‘b’, ‘a’, ‘b’, ‘b’, ‘b’, ‘b’, ‘b’, ‘b’, ‘a’, ‘a’, ‘a’, ‘a’, ‘b’, ‘a’, ‘a’, ‘a’, ‘a’]. - Index 0: The element is ‘a’. Increment counter to 1. - Index 1: The element is ‘b’. Counter remains 1. - Index 2: The element is ...

  7. [19]

    Result: 13 Correct Answer: 13 Table 22: Case Study 10 - Correct Prediction with GPT-4o mini (CoT prompt)

    The final count after iterating through all elements is 13. Result: 13 Correct Answer: 13 Table 22: Case Study 10 - Correct Prediction with GPT-4o mini (CoT prompt)

  8. [2022]

    arXiv preprint arXiv:2207.02098

    Neural networks and the chomsky hierarchy. arXiv preprint arXiv:2207.02098. Jacob Devlin. 2018. Bert: Pre-training of deep bidi- rectional transformers for language understanding. arXiv preprint arXiv:1810.04805. Guhao Feng, Bohang Zhang, Yuntian Gu, Haotian Ye, Di He, and Liw...

    2018 arXiv

  9. [2023]

    Paul Rodriguez, Janet Wiles, and Jeffrey L Elman

    Rwkv: Reinventing rnns for the transformer era.arXiv preprint arXiv:2305.13048. Paul Rodriguez, Janet Wiles, and Jeffrey L Elman. 1999. A recurrent neural network that learns to count.Con- nection Science, 11(1):5–40. Frank Rosenblatt. 1958. The perceptron: a probabilistic mod...

    1999 arXiv

  10. [2024]

    think step by step

    Transformers, parallel computation, and loga- rithmic depth.arXiv preprint arXiv:2402.09268. Rico Sennrich. 2015. Neural machine translation of rare words with subword units.arXiv preprint arXiv:1508.07909. Mirac Suzgun, Sebastian Gehrmann, Yonatan Belinkov, and Stuart M. Shie...

    2015 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.