Pith. sign in

REVIEW 4 major objections 4 minor 30 references

By breaking planning into a loop of single-instruction prompts on an external structured memory, the paper shows that small transformer language models can plan reliably, with Tower of Hanoi failures traced to arithmetic rather than policy.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 17:12 UTC pith:QBU4XORN

load-bearing objection COC's pointer-indexed context window is a genuinely useful idea, but the headline generalization claims are only as broad as the hand-authored instruction space they train on. the 4 major comments →

arxiv 2607.17710 v1 pith:QBU4XORN submitted 2026-07-20 cs.LG

Planning with Transformers: Chain of Computation and Structured Context Windows

Ehsan Futuhi , Nathan R. Sturtevant This is my paper
classification cs.LG
keywords Chain of ComputationStructured Context Windowlanguage model planningTower of HanoiBlocksWorldPancake Puzzlepushdown automatonlength generalization
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The paper tries to close the gap between the theoretical Turing-completeness of transformer language models and their unreliable performance on planning problems. It proposes Chain of Computation (COC), an architecture that runs the LM inside a loop: at each step the model reads one instruction from an external Structured Context Window, emits an action and a pointer to the next instruction, and writes new instructions back; the window keeps the LM's visible context constant-sized. The central experimental claim is that small, from-scratch-trained LMs using this loop reach success rates above 99.89% on unseen BlocksWorld and Pancake Puzzle instances, and that in Tower of Hanoi the remaining failures come from arithmetic on unseen numbers or unseen tokens rather than from the planning policy itself. When arithmetic is handled symbolically or the window is replaced by a pushdown stack, the same architecture solves Tower of Hanoi up to 20 disks, with plans exceeding one million actions. A sympathetic reader would take this as evidence that the bottleneck in long-horizon LM planning is bookkeeping—arithmetic and token knowledge—not the model's ability to learn a policy.

Core claim

The central claim is that a language model can be turned into a reliable planner by decomposing planning into an iterative sequence of near-constant-size prompt computations, each of which only updates a pointer and appends to an external tape. The model never sees the whole growing context; it sees only the instruction at the pointer, which is why, in the paper's terms, the approach leverages pattern-matching rather than long-context retrieval. The paper's main discovery is that this decomposition makes planning policies learnable by small models trained from scratch with little data: reported success rates exceed 99.89% on BlocksWorld and the Pancake Puzzle, and Tower of Hanoi failures are

What carries the argument

Chain of Computation (COC) is the iterative loop: at each iteration the LM reads the instruction at a pointer, writes any new instructions to the Structured Context Window (SCW), appends an action to the plan, and emits the next pointer, terminating at -1. The SCW is the external memory; in its append-only form it resembles a Turing machine tape, and in the PDA variant it becomes a LIFO stack, which eliminates the pointer arithmetic. The load-bearing sub-mechanism is the pointer: because the LM only sees the instruction at the pointer, the visible prompt stays roughly constant even when the total context grows linearly, preventing the retrieval failures that appear when an entire accumulated

Load-bearing premise

The argument stands only if the fixed set of solution patterns used to generate training data covers every configuration the planner will ever face; if a configuration falls outside those patterns, the model is not guaranteed to plan correctly.

What would settle it

The cleanest falsifier for the paper's causal claim is a controlled experiment the paper does not run: use the original pointer-based Tower of Hanoi prompts and targets, but replace only the pointer arithmetic with exact external computation, leaving the prompt and target structure byte-identical; if models then fail on instructions whose numbers were not in training, the 'arithmetic, not planning' conclusion is undermined. A secondary check: a start state already at the goal should yield zero actions; the paper already documents one Pancake case where the model emits unnecessary flips.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Small transformers can act as competent planning components in these domains: success rates above 99.89% on unseen instances after training on only hundreds of complete examples.
  • Long-horizon planning does not require a large context window: constant-size prompts keep per-step computation nearly constant, even for plans that grow to over a million actions.
  • Most Tower of Hanoi failures are not policy failures; the model solves them once arithmetic is outsourced or the stack layout removes pointer arithmetic.
  • The PDA formulation shows that for recursive planning domains, a transformer inside a loop plus a stack is sufficient to execute an exponentially long plan, suggesting pointer arithmetic is an avoidable source of error.
  • Within the covered instruction space, model accuracy should remain roughly flat as the plan length grows, rather than degrading with total context length.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper leaves implicit that COC's per-step prompt is essentially a fixed-size pattern-matching call; if this holds, the architecture could scale to arbitrarily long plans with the only costs being tape storage and the arithmetic module, not attention over a growing context.
  • The PDA formulation suggests a natural transfer: any recursively decomposable planning algorithm whose memory needs are LIFO could be executed by the same small-LM-plus-stack pattern; the paper only tests this on Tower of Hanoi.
  • A testable extension would be to feed the COC loop a domain whose optimal plans require non-stack memory (e.g., a queue or arbitrary backtracking); if the pointer-based window still succeeds, the memory-access claim is more general than the LIFO cases shown here.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper introduces Chain of Computation (COC), an architecture in which a small transformer-based LM runs inside an iterative loop, reading one instruction at a time from a Structured Context Window (SCW) and writing back new instructions, actions, and a pointer to the next instruction. Training is done from scratch on prompt–target pairs generated from three fixed, hand-authored planning strategies: recursive decomposition for Tower of Hanoi, unstack-then-stack for BlocksWorld, and flip-largest-unsorted for the Pancake Puzzle. The paper reports near-perfect success on BlocksWorld, Extended BlocksWorld, and the Pancake Puzzle; 92% average success on TOH with random held-out instruction pairs; and extension to TOH with up to 20 disks (over 1 million actions) using either symbolic arithmetic support or a PDA formulation of the SCW. The central claim is that small LMs can learn to execute planning policies and generalize from few instances once arithmetic and pointer bookkeeping are handled appropriately.

Significance. If the findings hold, they provide a practical demonstration that a constant-size prompt loop can mitigate the long-context retrieval failures documented in prior planning-with-LLM work, and they give concrete empirical weight to the theoretical Turing-completeness results for transformers. The appendices are unusually complete: full prompt–target traces for every domain, tokenizer and hyperparameter tables, and context-growth curves are all included. The PDA formulation in Appendix G is a clean formal contribution, and the paper is transparent about its failure cases. The main gap is that the reported generalization is demonstrated only over a bounded, randomly sampled test distribution generated from the same fixed strategy space used for training; the manuscript's title-level claim that COC learns and generalizes a planning policy needs to be scoped accordingly.

major comments (4)
  1. [§5.1 and Tables 1, 4, 6] All headline numbers for BlocksWorld, Extended BlocksWorld, and the Pancake Puzzle come from single runs with no error bars or repeated seeds. The 99.89% figure for Extended BlocksWorld rests on two failed configurations in one run at n=35 and n=36 (Table 4b). With 50 test configurations per n, even a single failure changes the row by 2 percentage points, so the 100% vs 98% difference is within sampling noise. Please report multiple seeds, standard deviations, or confidence intervals for at least the configurations that determine the headline claims.
  2. [§5.1 (Pancake pre-sorted case; Extended BlocksWorld n=35/36)] The paper states in the abstract that COC 'learn[s] planning policies and generalize[s]', but the evaluation only covers the support of the three fixed strategies described in §4. The two failure cases discussed in §5.1 are states outside that support: an already-sorted Pancake configuration and unseen stack configurations in Extended BlocksWorld. The manuscript's dismissal of the Pancake case as 'not a failure of the planning policy' because the goal is still reached is not convincing: a policy that emits two spurious flips is not a correct policy for that state. Either provide a completeness/correctness argument for the instruction space, or temper the generalization claim to explicitly say 'over a bounded random test distribution, conditioned on the chosen strategy'.
  3. [§5.3 and Appendix F] The isolation of arithmetic from planning is confounded. Comparing Appendix B (original TOH) with Appendix F (symbolic arithmetic) shows that the prompt and target formats differ in more than just whether arithmetic is delegated: the model now outputs symbolic expressions such as 'NEXT ID+1' and 'PTR=NEXT ID+2', and a separate module resolves them to concrete values. This changes the output distribution and token space substantially (e.g., large concrete integers disappear from the model's outputs), so the improved success could stem from a simpler target distribution rather than from the separation of arithmetic per se. To support the 'arithmetic, not planning' conclusion, control for template format (e.g., keep the same concrete template and only replace the arithmetic resolution step).
  4. [§6 and Appendix G] The 20-disk / 1-million-action result is stated in the abstract and conclusion but is not backed by a concrete experimental protocol in the main text. The PDA section says the model solves n=1..20 with a 15% holdout and 100% success, but no per-n table, number of seeds, or explicit verification that the n=20 instance actually generated all 1,048,575 moves without hitting decoding or context limits is provided. Given that this number is a headline contribution, please include the detailed result, ideally with the full trace length and failure analysis.
minor comments (4)
  1. [Appendix H, Table 5] The n=15, 15%-holdout failure reports an incorrect final state with no execution error. Since the outputs are move instructions, this implies a planning error somewhere; this case should be analyzed explicitly, as it runs against the paper's claim that TOH failures are primarily arithmetic.
  2. [Abstract / §5.1] The stated model sizes (10.8M–25.6M parameters) are only in Appendix A, Table 2. The main text's 'relatively small LMs' could be made precise by quoting these sizes in §5.
  3. [Figure 3] The figure reports mean success with error bars over five seeds, but the corresponding table (Table 5) reports only representative single-seed failure steps. It would be clearer to mark the failure points directly in the figure or provide per-seed success rates.
  4. [§3] The sentence 'the LM is able to learn a planning policy, predicts the world model, and performs the arithmetic operations' is broader than what is tested: TOH has no explicit state representation, so the world-model prediction is not learned there. Consider wording that distinguishes domains.

Circularity Check

0 steps flagged

No significant circularity: the COC evaluation is a self-contained supervised-learning pipeline, and no reported prediction reduces to its training inputs by construction.

full rationale

I walked the derivation chain from the COC architecture (Algorithm 1) through the three domain formulations to the experimental claims. The training targets are generated from hand-authored strategies (recursive HANOI, unstack-then-stack BlocksWorld, flip-largest-unsorted Pancake), and the paper openly describes this: 'we generate all prompt–target pairs for each value of n' and 'we generate complete prompt–target pairs only for a fixed number of randomly sampled problem instances for each value of n.' This is behavior cloning over demonstrations of a chosen algorithm, but that is not circular: the success claims are evaluated on disjoint instances and the model is not guaranteed to succeed. The paper itself documents non-trivial failures (the pre-sorted Pancake state causing spurious flips, Extended BlocksWorld failures at n=35/36, and TOH arithmetic failures), which shows the reported success rates are empirical outcomes rather than consequences of the data-generation procedure. There are no fitted scalar parameters renamed as predictions, no load-bearing self-citations (the reference list contains no work by the present authors), no imported uniqueness theorem, and no ansatz smuggled in via citation. The isolated-arithmetic experiment in Section 5.3 has a potential confound—symbolic placeholders change the target structure as well as removing arithmetic—but this is a validity concern, not an equivalence-by-construction between the conclusion and the input. Accordingly, no enumerated circular step can be exhibited with the required specificity, and the correct finding is no significant circularity.

Axiom & Free-Parameter Ledger

3 free parameters · 5 axioms · 1 invented entities

The ledger is light in the physics sense: there are no fitted constants or per-domain scales. The heavy unpaid input is the hand-authored instruction-template space (§4, Appendices B-G): every planning strategy whose generalization the paper measures is provided by the authors as target traces. This makes the headline "learned planning policy" a behavior-cloning statement within a chosen strategy, not an emergent planning algorithm. The other inputs are standard ML design choices (BPE, model size, data counts) with no sensitivity analysis.

free parameters (3)
  • Per-environment BPE vocabulary size / min frequency = 300 vocab; min freq 10 (TOH), 5 (BlocksWorld, Pancake)
    Hand-chosen tokenization; "unseen tokens" at test time, a stated failure source in TOH, is a direct artifact of this choice (Appendix A).
  • Training set size per complexity level = 500 configurations per n (train), 50 per n (test)
    Hand-chosen; the data-efficiency claims (Table 1) are statements about these specific counts, with no sensitivity analysis beyond the chosen grid.
  • Model hyperparameters = hidden 384/512, layers 6/8, LR 3e-4, dropout 0.1, 100 epochs
    No architecture/optimization sweep is reported; headline numbers could shift with these choices (Appendix A, Tables 2-3).
axioms (5)
  • ad hoc to paper Recursive HANOI decomposition is the plan structure taught to the model
    §4: training prompt-target pairs ARE expansions of HANOI(n,s,d,a)=HANOI(n-1,s,a,d)∘Move(n,s,d)∘HANOI(n-1,a,d,s); the model is trained to emit exactly this recursion, so its "planning policy" is this strategy by construction.
  • domain assumption Unstack-then-stack yields a valid BlocksWorld plan in at most 2(n-1) moves
    §4 and Appendix C fix this strategy as the source of all BlocksWorld targets; it is true for the classical domain but one of many valid strategies, so success measures imitation of this chosen strategy.
  • domain assumption Flip-largest-unsorted solves the Pancake puzzle in at most 2(n-1) flips
    §4 and Appendix D: all target traces realize this strategy; the pre-sorted edge case is absent from training, causing the one observed spurious-action case.
  • standard math Next-token prediction with masked prompt loss is a sound training objective for these transductions
    Appendix A: standard autoregressive objective; no formal guarantee that the local transductions are learnable — that is the empirical claim.
  • domain assumption The PDA formulation (bounded-N stack) faithfully represents the TOH plan generator
    Appendix G: standard automata modeling; the PDA removes pointer arithmetic and the model is trained on push/pop traces instead.
invented entities (1)
  • Structured Context Window (SCW) with pointer mechanism no independent evidence
    purpose: External memory that keeps the LM's visible prompt at constant size while the plan grows; the pointer selects the instruction to read/write at each loop step (Algorithm 1).
    A software architecture component, not a physical posit. All support is in-paper (the planning experiments); there is no external falsifiable handle. Listed for ledger completeness rather than as a graviton-style entity.

pith-pipeline@v1.3.0-alltime-deepseek · 29009 in / 18597 out tokens · 196182 ms · 2026-08-01T17:12:43.412091+00:00 · methodology

0 comments
read the original abstract

Large Language Models (LLMs) have had a remarkable impact across many areas of machine learning. However, recent studies have shown that they struggle to reliably solve planning problems. At the same time, theoretical results have shown that transformers, the core architecture underlying modern LLMs, are Turing-complete. In this work, we investigate this apparent gap between the theoretical computational power of LLMs and their empirical planning performance. We propose Chain of Computation (COC), a computational architecture that places a transformer-based LM inside an iterative loop, leveraging its strength as a pattern-matching system. The COC uses a Structured Context Window (SCW) which provides a constant-sized context window with support for choosing which window is used at each planning step. Within this architecture, the LM is able to learn a planning policy, predicts the world model, and performs the arithmetic operations required during planning. We show that, when given an append-only SCW (resembling a Turing Machine tape), even relatively small LMs trained from scratch can learn planning policies and generalize from a small number of training instances within each planning domain, achieving success rates above 99.89\% on BlocksWorld and the Pancake puzzle. Our analysis of failure cases in Tower of Hanoi (TOH) reveals that they arise from arithmetic operations or from encountering previously unseen tokens. We show that COC can solve TOH problem instances with up to 20 disks, requiring over 1 million actions, while requiring substantially less training data by either (1) planning with symbolical support for arithmetic or by (2) using a deterministic pushdown automaton (PDA) formulation for the SCW.

Figures

Figures reproduced from arXiv: 2607.17710 by Ehsan Futuhi, Nathan R. Sturtevant.

Figure 1
Figure 1. Figure 1: Comparison between standard LM planning and Chain of Computation (COC). Instead [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Planning domains used in our experiments. Left: Tower of Hanoi with [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Mean success rate on TOH across ran￾dom hold-out percentages of the training data, with error bars showing ± one standard devia￾tion over five random seeds. representative run from each hold-out setting, are provided in Appendix H. As expected, the av￾erage success rate decreases as the holdout per￾centage increases, dropping from 92% at a 5% holdout rate to 41% at 50%. Nevertheless, even with 35% of the d… view at source ↗
Figure 4
Figure 4. Figure 4: Planning instructions required for training to solve TOH instances up to disk count n. The x-axis is logarithmic. investigate the minimum amount of additional train￾ing data required as the number of disks increases in order to maintain a 100% success rate. For this experiment, we separate the planning and arithmetic operations so that they are handled independently. The prompt is passed to the language mo… view at source ↗
Figure 5
Figure 5. Figure 5: Decoder-only Transformer architecture used as the language model within the planner. [PITH_FULL_IMAGE:figures/full_fig_p018_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: One iteration of the planning loop when planning and arithmetic operations are separated. [PITH_FULL_IMAGE:figures/full_fig_p026_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Prompt size and cumulative context-window size over planning steps for BlocksWorld, [PITH_FULL_IMAGE:figures/full_fig_p033_7.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

30 extracted references · 15 linked inside Pith

  1. [1]

    Gpt-4 technical report.arXiv preprint arXiv:2303.08774,

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Ale- man, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report.arXiv preprint arXiv:2303.08774,

    Pith/arXiv arXiv

  2. [3]

    Thestepvariable indicates the order of execution from initialization to termination

    B TOWER OFHANOI: COMPLETEEXAMPLE In this section, we provide a complete execution of the planning procedure for solving HANOI(3, s, d, a), including all prompts and the corresponding responses expected from the LM. Thestepvariable indicates the order of execution from initialization to termination. Each prompt 18 Preprint Table 3: Training hyperparameters...

    1969

  3. [6]

    Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374,

    Mark Chen et al. Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374,

    Pith/arXiv arXiv

  4. [9]

    Looped transformers for length generalization

    Ying Fan, Yilun Du, Kannan Ramchandran, and Kangwook Lee. Looped transformers for length generalization. InInternational Conference on Learning Representations, volume 2025, pp. 14502–14520,

    2025

  5. [10]

    Stream of search (sos): Learning to search in language.arXiv preprint arXiv:2404.03683,

    12 Preprint Kanishk Gandhi, Denise Lee, Gabriel Grand, Muxin Liu, Winson Cheng, Archit Sharma, and Noah D Goodman. Stream of search (sos): Learning to search in language.arXiv preprint arXiv:2404.03683,

    Pith/arXiv arXiv

  6. [13]

    Reasoning with language model is planning with world model

    Shibo Hao, Yi Gu, Haodi Ma, Joshua Hong, Zhen Wang, Daisy Wang, and Zhiting Hu. Reasoning with language model is planning with world model. InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp. 8154–8173,

    2023

  7. [14]

    Gaussian error linear units (gelus).arXiv preprint arXiv:1606.08415,

    Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus).arXiv preprint arXiv:1606.08415,

    Pith/arXiv arXiv

  8. [15]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, et al. Qwen2. 5-coder technical report.arXiv preprint arXiv:2409.12186,

    Pith/arXiv arXiv

  9. [16]

    Be- yond a*: Better LLM planning via search dynamics bootstrapping

    Lucas Lehnert, Sainbayar Sukhbaatar, Paul McVay, Michael Rabbat, and Yuandong Tian. Be- yond a*: Better LLM planning via search dynamics bootstrapping. InICLR 2024 Workshop on Large Language Model (LLM) Agents,

    2024

  10. [17]

    Alex Lewandowski, Marlos C Machado, and Dale Schuurmans

    URLhttps://openreview.net/forum? id=rviGTsl0oy. Alex Lewandowski, Marlos C Machado, and Dale Schuurmans. Universal computation is intrinsic to language model decoding.arXiv preprint arXiv:2601.08061,

    arXiv

  11. [18]

    Llm-a*: Large language model enhanced incremental heuristic search on path planning

    14 Preprint Silin Meng, Yiwei Wang, Cheng-Fu Yang, Nanyun Peng, and Kai-Wei Chang. Llm-a*: Large language model enhanced incremental heuristic search on path planning. InFindings of the As- sociation for Computational Linguistics: EMNLP 2024, pp. 1087–1102,

    2024

  12. [19]

    Show your work: Scratchpads for intermediate computation with language models.arXiv preprint arXiv:2112.00114,

    Maxwell Nye, Anders J Andreassen, Guy Gur-Ari, Henryk Michalewski, David Bieber, David Dohan, Aitor Pang, Aitor Lewkowycz, Maarten Bosma, Edward Jiang, et al. Show your work: Scratchpads for intermediate computation with language models.arXiv preprint arXiv:2112.00114,

    Pith/arXiv arXiv

  13. [20]

    Understanding the capabilities of large language models for automated planning.arXiv preprint arXiv:2305.16151,

    Vishal Pallagani, Bharath Muppasani, Keerthiram Murugesan, Francesca Rossi, Biplav Srivastava, Lior Horesh, Francesco Fabiano, and Andrea Loreggia. Understanding the capabilities of large language models for automated planning.arXiv preprint arXiv:2305.16151,

    Pith/arXiv arXiv

  14. [21]

    Memory augmented large language models are computationally universal.arXiv preprint arXiv:2301.04589,

    Dale Schuurmans. Memory augmented large language models are computationally universal.arXiv preprint arXiv:2301.04589,

    Pith/arXiv arXiv

  15. [22]

    Challenging big-bench tasks and whether chain-of-thought can solve them

    Mirac Suzgun, Nathan Scales, Nathanael Sch¨arli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc Le, Ed Chi, Denny Zhou, et al. Challenging big-bench tasks and whether chain-of-thought can solve them. InFindings of the Association for Computational Lin- guistics: ACL 2023, pp. 13003–13051,

    2023

  16. [23]

    Llms as planning formalizers: A survey for leveraging large language models to construct automated planning models

    Marcus Tantakoun, Christian Muise, and Xiaodan Zhu. Llms as planning formalizers: A survey for leveraging large language models to construct automated planning models. InFindings of the Association for Computational Linguistics: ACL 2025, pp. 25167–25188,

    2025

  17. [24]

    Gemini: a family of highly capable multimodal models.arXiv preprint arXiv:2312.11805,

    Gemini Team, Rohan Anil, Sebastian Borgeaud, Jean-Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M Dai, Anja Hauth, Katie Millican, et al. Gemini: a family of highly capable multimodal models.arXiv preprint arXiv:2312.11805,

    Pith/arXiv arXiv

  18. [25]

    Llama 2: Open founda- tion and fine-tuned chat models.arXiv preprint arXiv:2307.09288,

    15 Preprint Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Niko- lay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open founda- tion and fine-tuned chat models.arXiv preprint arXiv:2307.09288,

    Pith/arXiv arXiv

  19. [26]

    Bloomberggpt: A large language model for finance.arXiv preprint arXiv:2303.17564,

    Shijie Wu, Ozan Irsoy, Steven Lu, Vadim Dabravolski, Mark Dredze, Sebastian Gehrmann, Prab- hanjan Kambadur, David Rosenberg, and Gideon Mann. Bloomberggpt: A large language model for finance.arXiv preprint arXiv:2303.17564,

    Pith/arXiv arXiv

  20. [27]

    Trading-r1: Financial trading with llm reasoning via reinforcement learning.arXiv preprint arXiv:2509.11420,

    Yijia Xiao, Edward Sun, Tong Chen, Fang Wu, Di Luo, and Wei Wang. Trading-r1: Financial trading with llm reasoning via reinforcement learning.arXiv preprint arXiv:2509.11420,

    arXiv

  21. [28]

    Training language models with memory augmentation

    Zexuan Zhong, Tao Lei, and Danqi Chen. Training language models with memory augmentation. InProceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pp. 5657–5673,

    2022

  22. [1979]

    doi: https://doi.org/10

    ISSN 0012-365X. doi: https://doi.org/10. 1016/0012-365X(79)90068-2. URLhttps://www.sciencedirect.com/science/ article/pii/0012365X79900682. Robert Geirhos, J ¨orn-Henrik Jacobsen, Claudio Michaelis, Richard Zemel, Wieland Brendel, Matthias Bethge, and Felix A Wichmann. Shortcut learning in deep neural networks.Nature Machine Intelligence, 2(11):665–673,

    arXiv

  23. [2016]

    with a Metaspace pre-tokenizer and decoder. The BPE vocabulary is ini- tialized with the set of characters appearing in the corresponding environment’s prompt–target text, together with the special tokens[PAD],[BOS],[EOS], and[UNK]. We do not train the tokenizer on metadata fields such as problem size, step index, or configuration identifiers; only the pr...

    2048

  24. [2020]

    Exploring and benchmarking the planning capabil- ities of large language models.arXiv preprint arXiv:2406.13094,

    Bernd Bohnet, Azade Nova, Aaron T Parisi, Kevin Swersky, Katayoon Goshvadi, Hanjun Dai, Dale Schuurmans, Noah Fiedel, and Hanie Sedghi. Exploring and benchmarking the planning capabil- ities of large language models.arXiv preprint arXiv:2406.13094,

    Pith/arXiv arXiv

  25. [2021]

    Dast: Context-aware compression in llms via dynamic allocation of soft tokens

    Shaoshen Chen, Yangning Li, Zishan Xu, Yongqin Zeng, Shunlong Wu, Xinshuo Hu, Zifei Shan, Xin Su, Jiwei Tang, Yinghui Li, et al. Dast: Context-aware compression in llms via dynamic allocation of soft tokens. InFindings of the Association for Computational Linguistics: ACL 2025, pp. 20544–20552,

    2025

  26. [2022]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.arXiv preprint arXiv:2501.12948,

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.arXiv preprint arXiv:2501.12948,

    Pith/arXiv arXiv

  27. [2023]

    Can large language models be good path planners? a benchmark and investigation on spatial-temporal reasoning

    Mohamed Aghzal, Erion Plaku, and Ziyu Yao. Can large language models be good path planners? a benchmark and investigation on spatial-temporal reasoning. InICLR 2024 Workshop on LLM Agents,

    2024

  28. [2024]

    Analysis of optimality of large language models on planning problems.arXiv preprint arXiv:2604.02910,

    Bernd Bohnet, Michael C Mozer, Kevin Swersky, Wil Cunningham, Aaron Parisi, Kathleen Kenealy, and Noah Fiedel. Analysis of optimality of large language models on planning problems.arXiv preprint arXiv:2604.02910,

    Pith/arXiv arXiv

  29. [2025]

    Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168,

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168,

    Pith/arXiv arXiv

  30. [2026]

    URLhttps://ojs.aaai.org/index.php/ AAAI/article/view/42130

    doi: 10.1609/aaai.v40i48.42130. URLhttps://ojs.aaai.org/index.php/ AAAI/article/view/42130. Satwik Bhattamishra, Arkil Patel, and Navin Goyal. On the computational power of transformers and its implications in sequence modeling. InProceedings of the 24th Conference on Computa- tional Natural Language Learning, pp. 455–475,

    doi:10.1609/aaai.v40i48.42130