Pith. sign in

REVIEW 3 major objections 5 minor 83 references

Popular post-training methods fail to carry learned procedures from code or graphs into natural language, but a two-stage curriculum that trains on symbols first and language second closes much of the gap.

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-03 04:56 UTC pith:ZNQHKCCP

load-bearing objection Solid, budget-matched demonstration that graph-then-NL curriculum transfers where symbolic-only training doesn't; Code condition is confounded but main result stands. the 3 major comments →

arxiv 2602.03542 v2 pith:ZNQHKCCP submitted 2026-02-03 cs.CL cs.LG

Can Large Language Models Generalize Procedures Across Representations?

Fangru Lin , Valentin Hofmann , Xingchen Wan , Weixing Wang , Zifeng Ding , Anthony G. Cohn , Janet B. Pierrehumbert This is my paper
classification cs.CL cs.LG MSC 68T50
keywords cross-representation generalizationprocedure learningtwo-stage curriculumreinforcement learninggenerative analogyplanningcode-graph-natural languageGRPO
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 establish that LLMs do not naturally generalize procedures across representations, and that a carefully ordered curriculum fixes this. Using isomorphic tasks—the same DAG longest-path planning problem expressed as natural language, a graph adjacency list, and a Python function—the authors show that training on any single representation with four popular post-training methods does not reliably transfer to the other two. They then propose a two-stage reinforcement learning curriculum, first on symbolic data, then on natural language, which at equal compute lets a 1.5B Qwen model match zero-shot GPT-4o on naturalistic planning. The paper also argues that successful transfer behaves like generative analogy: it correlates with structural similarity to a few training instances rather than with the sheer number of similar instances.

Core claim

Naive post-training on a single representation—natural language, graph, or code—fails to reliably generalize to the other two, even though all three encode the identical underlying procedure: computing the critical path in a directed acyclic graph. The authors' two-stage curriculum, GRPO on Graph for 40 training steps followed by GRPO on NL for 40 steps, reaches 0.782 test accuracy on NL, matching zero-shot GPT-4o, while NL-only training for the same total budget reaches 0.698. Order is decisive: reversing the curriculum (NL then Graph) drops NL accuracy to 0.431, well below NL-only training. The authors interpret successful transfer as generative analogy, since test performance correlates m

What carries the argument

The isomorphic task design: the same asynchronous-planning procedure (longest path in a DAG) is presented in three representations—natural-language step lists with constraints, graph adjacency lists with node durations, and a Python function using a networkx longest-path implementation. The central intervention is a two-stage curriculum: GRPO reinforcement learning on symbolic data (Graph or Code) for the first half of training, then on natural language for the second half. The analysis machinery is an analogical strength measure built from structure-mapping theory, using a Weisfeiler–Lehman subtree kernel on the task DAGs and a histogram-Jaccard similarity on node durations, to compare anal

Load-bearing premise

The three task variants are assumed to be procedurally equivalent and to differ only in surface form, but the Code variant provides the complete algorithm in the prompt while Graph and NL require the model to induce it, so the transfer gaps may reflect how much algorithmic information each representation contains rather than representation format alone.

What would settle it

Take the Code condition and remove the function body (e.g., replace the networkx implementation with a comment), train on that version, and test on NL. If Code-to-NL transfer drops to the Graph-to-NL level, the gap is driven by algorithmic information; if transfer stays high despite the missing algorithm, representation format itself is the key variable.

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

If this is right

  • Training on code or graph data alone cannot be assumed to improve natural-language reasoning, even when the underlying procedures are identical.
  • A symbol-first, language-second reinforcement curriculum yields large gains on natural-language performance at the same compute budget as language-only training.
  • Curriculum order is decisive; training language first and symbols second degrades performance below language-only training, and replacing the second-stage RL with SFT distillation also fails.
  • The curriculum transfers across model families (Qwen and Olmo-2) and to math and physics tasks, though often with only comparable in-domain accuracy.
  • The curriculum improves robustness to dialect variation (NL-AAVE) compared with NL-only training, but a substantial gap remains between standard NL and the dialect.

Where Pith is reading between the lines

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

  • If procedures learned in one representation do not transfer without explicit adaptation, then reasoning in current LLMs is representation-bound; this suggests cross-representational alignment or mixed-representation curricula as a stronger research direction.
  • The Code condition hands the model the complete algorithm in the prompt, while Graph and NL require inducing it from examples; part of the observed transfer gap may be an information asymmetry rather than a pure representational effect—a version of Code with the function body hidden would separate these.
  • The curriculum is a practical recipe for domains with abundant synthetic symbolic data but scarce natural-language data: learn the abstract procedure in the symbolic form, then adapt to the target representation with RL.
  • The analogy-based explanation implies that data selection for post-training could target structurally similar exemplars rather than simply more data; this is testable by designing training sets with controlled analogical strength.

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

3 major / 5 minor

Summary. The paper asks whether LLMs can generalize procedures across three intentionally isomorphic representations — natural language (NL), graph adjacency lists, and code — using an asynchronous planning task whose solution is a longest-path computation. The authors train several model families (Qwen, Llama, Olmo) with four post-training methods (SFT, distillation, STaR, GRPO) on one representation and test on all. They report that single-representation training, especially on Graph or Code, transfers poorly to NL, while a two-stage GRPO curriculum with Graph first and NL second matches the training budget of NL-only training and substantially improves NL accuracy (0.782 vs. 0.698 for Qwen-1.5B), matching zero-shot GPT-4o on canonical NL and improving on the NL-AAVE dialect probe. Additional experiments on math and physics and on Olmo-2-7B are presented, and an analysis claims that successful transfer is better explained by analogical structure similarity than by frequency of similar training examples.

Significance. If the main result holds, it is a useful and nontrivial finding: current post-training recipes can be surface-sensitive, and a symbol-first, NL-second curriculum can recover much of the cross-representation gap at small scale. The budget-matched control (40+40 vs. 80 steps), the genuine out-of-distribution NL-AAVE probe, the evaluation across three model families, and the public code/data link are concrete strengths. The main weakness is that the Code condition is not information-equivalent to Graph and NL, so the blanket claim that 'naive training on a single representation fails to generalize' is only solidly supported for the Graph condition. The analogy-vs-frequency analysis also contains an internal significance inconsistency. These issues are fixable by reframing or additional controls, and the core curriculum result appears defensible.

major comments (3)
  1. [Section 2 / Figure 1 / Appendix A.1] The Code condition is not procedurally equivalent to Graph and NL in the sense the paper requires. The Code prompt contains the complete networkx longest-path implementation, so the model can answer by simulating an explicit algorithm, whereas Graph and NL require inducing the longest-path procedure from examples. Durations are also numeric weights in Code but natural-language text in Graph and NL. Consequently, a Code-to-NL transfer failure may reflect an inability to re-implement an explicitly provided algorithm in NL, or an NL parsing bottleneck, rather than lack of representation-agnostic procedure learning. Section 3.2's 'Across all LLMs and post-training methods...' and Section 6's code/graph claims therefore overstate what the experiment shows. Please either add a Code condition that does not embed the algorithm, or explicitly restrict the main failure claim to Graph and revise th
  2. [Table 3 / Appendix A.8] The Table 3 caption states 'All results are statistically significant,' but Appendix A.8 shows otherwise. For Train: NL, Test: Graph, the frequency-based correlation with p=0.1 is rho_p = 0.124 with p=0.064, i.e., not significant at the 0.05 level, yet this value appears in Table 3. In addition, the reported maxima are selected from sweeps over k and p without any correction for multiple comparisons; many swept values are non-significant. This makes the 'analogy outperforms frequency' conclusion more fragile than the text suggests. Please correct the caption and either pre-specify k and p or apply a multiple-testing correction, and report the selection procedure transparently.
  3. [Abstract / Section 4.1] The claim that the curriculum 'closely match[es] zero-shot GPT-4o' is exact on canonical NL (0.782 vs. 0.782) but not on NL-AAVE, where the curriculum scores 0.573 against GPT-4o's 0.724. Since NL-AAVE is introduced as a robustness probe and the abstract uses 'naturalistic planning,' this gap should be acknowledged in the headline claim. The conclusion is not invalidated, but the wording overstates the match.
minor comments (5)
  1. [Section 7] Typo in the first sentence: 'my In this paper' should read 'In this paper.'
  2. [Table 1] Header contains 'NL-AA VE' with an extra space; please correct to 'NL-AAVE.'
  3. [Section 4.1] The sentence 'the 1.5B model trained for 80 steps outperforms the 3B model trained on NL alone for 40 steps' is clear, but the immediately following comparison to the 7B variant is ambiguous: Table 1 reports a 7B model trained on NL for 40 steps, not a 7B model trained with the curriculum. Please state explicitly which 7B configuration is being compared.
  4. [Figure 2 caption] Minor formatting: 'Results inorangebackground' is missing a space; also 'NL-AA VE' appears elsewhere in the text.
  5. [Section 2] The sentence 'The only difference is the representation format' should be qualified, since the Code prompt includes an explicit algorithm and the Graph/NL prompts do not.

Circularity Check

0 steps flagged

No construction-level circularity: the headline results are held-out measurements, the curriculum is an intervention tested against baselines, and the analogy analysis uses stated parameters rather than fitting the conclusion.

full rationale

The paper's central claims are empirical rather than derivational. Table 1 reports test accuracies on disjoint held-out NL and NL-AAVE sets, and the Section 3.2 failure-of-transfer claim is a measurement across models and methods, not a quantity derived from its own inputs. The two-stage curriculum is an intervention evaluated against NL-only and reversed-order baselines; no fitted parameter is renamed as a prediction. Eq. (1) defines analogical strength with α=0.4 and 3 Weisfeiler-Lehman iterations as stated settings; the frequency-vs-analogy comparison sweeps k and p and reports the full sweeps in Appendix A.8, so the conclusion is not a hidden fit to the target. Self-citations such as AsyncHow (Lin et al. 2024a) and NL-AAVE (Lin et al. 2024b) supply datasets, and Hofmann et al. (2024) supplies an interpretive framework; they do not function as the load-bearing derivation. The most serious concern is experimental validity rather than circularity: the Code condition embeds a complete networkx longest-path implementation in the prompt, so Code-to-NL transfer failures may confound representation with algorithmic information. That is a confound, not a by-construction equivalence between an output and an input. No step in the paper reduces its own claimed result to its own assumptions. Under the stated rules requiring quoted evidence of a specific reduction, no circular step is present.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 0 invented entities

The main empirical results are measurements, so the free-parameter burden is concentrated in the interpretive analogy analysis (Eq. 1, alpha, WL depth, k/p selection) rather than in the headline accuracies. The central claim rests on the isomorphism assumption between the three data formats (Section 2) and on the evaluation design. No new entities are postulated.

free parameters (3)
  • alpha (analogical-strength discount) = 0.4
    Hand-set in Eq. 1 to weight binary (relational) similarity over unary item similarity; used only in the Section 5.1 interpretation, not in the headline results.
  • WL subtree kernel iterations = 3
    Chosen for binary-structure similarity in the analogical-strength measure; affects the analogy analysis, not the main accuracies.
  • k / p sweep selection in Table 3 = rho_k max over k in {1..10}; rho_p max over p in {0.1..0.9}
    Headline correlations are maxima over 90 configurations per setting with no multiple-comparison correction, inflating reported support for the analogy hypothesis.
axioms (4)
  • domain assumption NL planning instances translate losslessly to DAG longest-path problems (constraints to edges, durations to node weights), so the three formats train the same procedure.
    Section 2 and Figure 1: the entire cross-representation design depends on this equivalence, which is asserted following AsyncHow (Lin et al. 2024a).
  • domain assumption Code, Graph, and NL are comparable 'surface forms' of the same task for the learner, despite the Code prompt embedding the full algorithm.
    Appendix A.1 Code prompt contains a complete networkx longest-path implementation; the paper treats representation format and algorithmic-information content as one variable, which confounds the transfer comparison.
  • domain assumption Structure-mapping analogical strength (Eq. 1) is a valid similarity measure for these DAGs.
    Section 5.1 imports Gentner's structure-mapping theory; the specific instantiation (alpha=0.4, histogram-Jaccard for unary, WL-3 for binary) is chosen by the authors.
  • domain assumption Complexity stratification by node+edge counts captures task difficulty, and test-set accuracy on the held-out 225 instances measures cross-representation generalization.
    Section 3.1 'stratified sampling based on complexities defined in Section 2'; this is an evaluation-design assumption carried over from Lin et al. 2024b.

pith-pipeline@v1.3.0-alltime-deepseek · 4144 in / 4386 out tokens · 184734 ms · 2026-08-03T04:56:18.418902+00:00 · methodology

0 comments
read the original abstract

Large language models (LLMs) are trained and tested extensively on symbolic representations such as code and graphs, yet real-world user tasks are often specified in natural language. To what extent can LLMs generalize across these representations? Here, we approach this question by studying isomorphic tasks involving procedures represented in code, graphs, and natural language (e.g., scheduling steps in planning). We find that training LLMs with popular post-training methods on graphs or code data alone does not reliably generalize to corresponding natural language tasks, while training solely on natural language can lead to inefficient performance gains. To address this gap, we propose a two-stage reinforcement learning curriculum that first trains on symbolic, then natural language data. The curriculum substantially improves model performance across model families and tasks. Remarkably, a 1.5B Qwen model trained by our method can closely match zero-shot GPT-4o in naturalistic planning. Finally, our analysis suggests that successful cross-representation generalization can be interpreted as a form of generative analogy, which our curriculum effectively encourages. The dataset and code used in this paper can be found \href{https://github.com/fangru-lin/procedure_generalization_llm}{here}.

Figures

Figures reproduced from arXiv: 2602.03542 by Anthony G. Cohn, Fangru Lin, Janet B. Pierrehumbert, Valentin Hofmann, Weixing Wang, Xingchen Wan, Zifeng Ding.

Figure 1
Figure 1. Figure 1: Illustration of cross-representation generalization of the planning task studied in this paper. Each frame describes a question and its corresponding underlying graph problems as well as their solutions (critical paths in red). The top frame describes a natural language planning problem in NL, where the problem is given in natural language. Essentially, the shortest time needed for this task can be solved … view at source ↗
Figure 2
Figure 2. Figure 2: Qwen models’ performance after training. We train models on one representation from NL, Graph, and Code, respectively (left to right), and test them on all representations (with the particular aim to optimize on NL). Results in orange background are in the same distribution as the training set (e.g., train on NL and test on NL). Up/down arrows denote test results significantly better/worse than untuned bas… view at source ↗
Figure 3
Figure 3. Figure 3: Main results for Llama models after training. We train models on one training set from NL, Graph, and Code, respectively (left to right), and test them on all settings (with the particular aim to optimize on NL representations). Results in orange background are in the same distribution as the training set (e.g., train on NL and test on NL). Up/down arrows denote test results significantly better/worse than… view at source ↗
Figure 4
Figure 4. Figure 4: Main results for Olmo models after training. We train models on one training set from NL, Graph, and Code, respectively (left to right), and test them on all settings (with the particular aim to optimize on NL representations). Results in orange background are in the same distribution as the training set (e.g., train on NL and test on NL). Up/down arrows denote test results significantly better/worse than … view at source ↗
Figure 5
Figure 5. Figure 5: Reward curve for NL, Graph training from cold start, and (Graph->)NL which is NL training initialized with the final checkpoint of Graph. The learning curve of (Graph->)NL resembles Graph more than NL. 16 [PITH_FULL_IMAGE:figures/full_fig_p016_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Qwen performance change (before and after training) for the main experiments. We train models on one representation from NL, Graph, and Code, respectively (left to right), and test them on all representations (with the particular aim to optimize on NL). Results in orange background are in the same distribution as the training set (e.g., train on NL and test on NL). Distillation can sometimes exacerbate per… view at source ↗
Figure 7
Figure 7. Figure 7: Test performance on the same representations of the training data after training of instances of complexity 14 or lower (here complexity means the total count of edges and nodes in each corresponding graph). Results are aggregated based on different complexity levels of the test cases. Results in orange background share the same range of complexity with training data. We compare cross-representation genera… 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

83 extracted references · 29 linked inside Pith

  1. [1]

    and Thompson, V

    Ackerman, R. and Thompson, V. A. Meta-reasoning: Monitoring and control of thinking and reasoning. Trends in cognitive sciences, 21 0 (8): 0 607--617, 2017

    2017

  2. [2]

    To code, or not to code? exploring impact of code in pre-training

    Aryabumi, V., Su, Y., Ma, R., Morisot, A., Zhang, I., Locatelli, A., Fadaee, M., \"U st \"u n, A., and Hooker, S. To code, or not to code? exploring impact of code in pre-training. arXiv preprint arXiv:2408.10914, 2024

    Pith/arXiv arXiv 2024

  3. [3]

    D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al

    Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language models are few-shot learners. Advances in neural information processing systems, 33: 0 1877--1901, 2020

    1901

  4. [4]

    H., Baker, B., Gao, L., Aschenbrenner, L., Chen, Y., Ecoffet, A., Joglekar, M., Leike, J., et al

    Burns, C., Izmailov, P., Kirchner, J. H., Baker, B., Gao, L., Aschenbrenner, L., Chen, Y., Ecoffet, A., Joglekar, M., Leike, J., et al. Weak-to-strong generalization: Eliciting strong capabilities with weak supervision. In International Conference on Machine Learning, pp.\ 4971--5012. PMLR, 2024

    2024

  5. [5]

    Plan recognition in natural language dialogue

    Carberry, S. Plan recognition in natural language dialogue. MIT press, 1990

    1990

  6. [6]

    Logic distillation: Learning from code function by function for planning and decision-making

    Chen, D., Zhang, S., Gao, F., Zhuang, Y., Tang, S., Liu, Q., and Xu, M. Logic distillation: Learning from code function by function for planning and decision-making. arXiv preprint arXiv:2407.19405, 2024

    arXiv 2024

  7. [7]

    V., Levine, S., and Ma, Y

    Chu, T., Zhai, Y., Yang, J., Tong, S., Xie, S., Schuurmans, D., Le, Q. V., Levine, S., and Ma, Y. SFT memorizes, RL generalizes: A comparative study of foundation model post-training. arXiv preprint arXiv:2501.17161, 2025

    Pith/arXiv arXiv 2025

  8. [8]

    Leveraging procedural generation to benchmark reinforcement learning

    Cobbe, K., Hesse, C., Hilton, J., and Schulman, J. Leveraging procedural generation to benchmark reinforcement learning. In International conference on machine learning, pp.\ 2048--2056. PMLR, 2020

    2048

  9. [9]

    Understanding the generative capacity of analogies as a tool for explanation

    David Wong, E. Understanding the generative capacity of analogies as a tool for explanation. Journal of research in science teaching, 30 0 (10): 0 1259--1272, 1993

    1993

  10. [10]

    Deepseek- R 1: Incentivizing reasoning capability in LLM s via reinforcement learning, 2025

    DeepSeek-AI. Deepseek- R 1: Incentivizing reasoning capability in LLM s via reinforcement learning, 2025. URL https://arxiv.org/abs/2501.12948

    Pith/arXiv arXiv 2025

  11. [11]

    TCP : a benchmark for temporal constraint-based planning

    Ding, Z., Yan, S., Yuan, M., Hu, X., Lin, F., and Vlachos, A. TCP : a benchmark for temporal constraint-based planning. In Christodoulopoulos, C., Chakraborty, T., Rose, C., and Peng, V. (eds.), Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp.\ 22452--22475, Suzhou, China, November 2025. Association for Computati...

    doi:10.18653/v1/2025.emnlp-main.1142 2025

  12. [12]

    A., Hummel, J

    Doumas, L. A., Hummel, J. E., and Sandhofer, C. M. A theory of the discovery and predication of relational concepts. Psychological review, 115 0 (1): 0 1, 2008

    2008

  13. [13]

    A., Puebla, G., Martin, A

    Doumas, L. A., Puebla, G., Martin, A. E., and Hummel, J. E. A theory of relation learning and cross-domain generalization. Psychological review, 129 0 (5): 0 999, 2022

    2022

  14. [14]

    The llama 3 herd of models

    Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al. The llama 3 herd of models. arXiv e-prints, pp.\ arXiv--2407, 2024

    2024

  15. [15]

    D., and Gentner, D

    Falkenhainer, B., Forbus, K. D., and Gentner, D. The structure-mapping engine: Algorithm and examples. Artificial intelligence, 41 0 (1): 0 1--63, 1989

    1989

  16. [16]

    and Sims, C

    Fang, Z. and Sims, C. R. Humans learn generalizable representations through efficient coding. Nature Communications, 16 0 (1): 0 3989, 2025

    2025

  17. [17]

    Pal: Program-aided language models

    Gao, L., Madaan, A., Zhou, S., Alon, U., Liu, P., Yang, Y., Callan, J., and Neubig, G. Pal: Program-aided language models. In International Conference on Machine Learning, pp.\ 10764--10799. PMLR, 2023

    2023

  18. [18]

    Generative analogies as mental models

    Gentner, D. Generative analogies as mental models. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 3, 1981

    1981

  19. [19]

    Structure-mapping: A theoretical framework for analogy

    Gentner, D. Structure-mapping: A theoretical framework for analogy. Cognitive science, 7 0 (2): 0 155--170, 1983

    1983

  20. [20]

    L., Callaway, F., Chang, M

    Griffiths, T. L., Callaway, F., Chang, M. B., Grant, E., Krueger, P. M., and Lieder, F. Doing more with less: meta-reasoning and meta-learning in humans and machines. Current Opinion in Behavioral Sciences, 29: 0 24--30, 2019

    2019

  21. [21]

    Mini LLM : Knowledge distillation of large language models

    Gu, Y., Dong, L., Wei, F., and Huang, M. Mini LLM : Knowledge distillation of large language models. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=5h0qf7IBZZ

    2024

  22. [22]

    The unreasonable effectiveness of easy training data for hard tasks

    Hase, P., Bansal, M., Clark, P., and Wiegreffe, S. The unreasonable effectiveness of easy training data for hard tasks. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp.\ 7002--7024, 2024

    2024

  23. [23]

    Measuring mathematical problem solving with the MATH dataset

    Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), 2021. URL https://openreview.net/forum?id=7Bywt2mQsCe

    2021

  24. [24]

    Derivational morphology reveals analogical generalization in large language models

    Hofmann, V., Weissweiler, L., Mortensen, D., Sch \"u tze, H., and Pierrehumbert, J. Derivational morphology reveals analogical generalization in large language models. arXiv preprint arXiv:2411.07990, 2024

    Pith/arXiv arXiv 2024

  25. [25]

    Holyoak, K. J. and Thagard, P. Mental leaps: Analogy in creative thought. MIT press, 1996

    1996

  26. [26]

    Openrlhf: An easy-to-use, scalable and high-performance rlhf framework

    Hu, J., Wu, X., Zhu, Z., Wang, W., Zhang, D., Cao, Y., et al. Openrlhf: An easy-to-use, scalable and high-performance rlhf framework. arXiv preprint arXiv:2405.11143, 2024

    Pith/arXiv arXiv 2024

  27. [27]

    Open-reasoner-zero: An open source approach to scaling up reinforcement learning on the base model

    Hu, J., Zhang, Y., Han, Q., Jiang, D., Zhang, X., and Shum, H.-Y. Open-reasoner-zero: An open source approach to scaling up reinforcement learning on the base model. arXiv preprint arXiv:2503.24290, 2025

    Pith/arXiv arXiv 2025

  28. [28]

    Loong: Synthesize long chain-of-thoughts at scale through verifiers

    Huang, X., Franke, G., Yang, Z., Bai, J., Bai, W., Bi, J., Ding, Z., Duan, Y., Fan, C., Fan, W., et al. Loong: Synthesize long chain-of-thoughts at scale through verifiers. In NeurIPS 2025 Workshop on Bridging Language, Agent, and World Models for Reasoning and Planning, 2025

    2025

  29. [29]

    Hummel, J. E. and Holyoak, K. J. Distributed representations of structure: A theory of analogical access and mapping. Psychological review, 104 0 (3): 0 427, 1997

    1997

  30. [30]

    Code pretraining improves entity tracking abilities of language models

    Kim, N., Schuster, S., and Toshniwal, S. Code pretraining improves entity tracking abilities of language models. arXiv preprint arXiv:2405.21068, 2024

    Pith/arXiv arXiv 2024

  31. [31]

    S., Reid, M., Matsuo, Y., and Iwasawa, Y

    Kojima, T., Gu, S. S., Reid, M., Matsuo, Y., and Iwasawa, Y. Large language models are zero-shot reasoners. Advances in neural information processing systems, 35: 0 22199--22213, 2022

    2022

  32. [32]

    M., and Raghunathan, A

    Kotha, S., Springer, J. M., and Raghunathan, A. Understanding catastrophic forgetting in language models via implicit inference. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=VrHiF2hsrm

    2024

  33. [33]

    Code simulation challenges for large language models

    La Malfa, E., Weinhuber, C., Torre, O., Lin, F., Marro, S., Cohn, A., Shadbolt, N., and Wooldridge, M. Code simulation challenges for large language models. arXiv preprint arXiv:2401.09074, 2024

    Pith/arXiv arXiv 2024

  34. [34]

    A., Marro, S., Cohn, A., Shadbolt, N., and Wooldridge, M

    La Malfa, E., Weinhuber, C., Torre, O., Lin, F., Huang, X. A., Marro, S., Cohn, A., Shadbolt, N., and Wooldridge, M. Code simulation as a proxy for high-order tasks in large language models. arXiv preprint arXiv:2502.03568, 2025

    Pith/arXiv arXiv 2025

  35. [35]

    Lambert, N., Morrison, J., Pyatkin, V., Huang, S., Ivison, H., Brahman, F., Miranda, L. J. V., Liu, A., Dziri, N., Lyu, S., et al. T " ulu 3: Pushing frontiers in open language model post-training. arXiv preprint arXiv:2411.15124, 2024

    Pith/arXiv arXiv 2024

  36. [36]

    Why and how to learn why: Analysis-based generalization of procedures

    Lewis, C. Why and how to learn why: Analysis-based generalization of procedures. Cognitive Science, 12 0 (2): 0 211--256, 1988

    1988

  37. [37]

    and Mitchell, M

    Lewis, M. and Mitchell, M. Evaluating the robustness of analogical reasoning in large language models. arXiv preprint arXiv:2411.14215, 2024

    Pith/arXiv arXiv 2024

  38. [38]

    Codei/o: Condensing reasoning patterns via code input-output prediction

    Li, J., Guo, D., Yang, D., Xu, R., Wu, Y., and He, J. Codei/o: Condensing reasoning patterns via code input-output prediction. arXiv preprint arXiv:2502.07316, 2025

    Pith/arXiv arXiv 2025

  39. [39]

    M., Cohn, A., and Pierrehumbert, J

    Lin, F., La Malfa, E., Hofmann, V., Yang, E. M., Cohn, A., and Pierrehumbert, J. B. Graph-enhanced large language models in asynchronous plan reasoning. arXiv preprint arXiv:2402.02805, 2024 a

    Pith/arXiv arXiv 2024

  40. [40]

    B., and Wei, F

    Lin, F., Mao, S., La Malfa, E., Hofmann, V., de Wynter, A., Wang, X., Chen, S.-Q., Wooldridge, M., Pierrehumbert, J. B., and Wei, F. One language, many gaps: Evaluating dialect fairness and robustness of large language models in reasoning tasks. arXiv preprint arXiv:2410.11005, 2024 b

    Pith/arXiv arXiv 2024

  41. [41]

    The centrality of language in human cognition

    Lupyan, G. The centrality of language in human cognition. Language Learning, 66 0 (3): 0 516--553, 2016

    2016

  42. [42]

    At which training stage does code data help LLM s reasoning? In The Twelfth International Conference on Learning Representations, 2024

    MA, Y., Liu, Y., Yu, Y., Zhang, Y., Jiang, Y., Wang, C., and Li, S. At which training stage does code data help LLM s reasoning? In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=KIPJKST4gw

    2024

  43. [43]

    Note on the sampling error of the difference between correlated proportions or percentages

    McNemar, Q. Note on the sampling error of the difference between correlated proportions or percentages. Psychometrika, 12 0 (2): 0 153--157, 1947

    1947

  44. [44]

    Linguistic regularities in continuous space word representations

    Mikolov, T., Yih, W.-t., and Zweig, G. Linguistic regularities in continuous space word representations. In Proceedings of the 2013 conference of the north american chapter of the association for computational linguistics: Human language technologies, pp.\ 746--751, 2013

    2013

  45. [45]

    G., Rao, K., Sadigh, D., and Zeng, A

    Mirchandani, S., Xia, F., Florence, P., Ichter, B., Driess, D., Arenas, M. G., Rao, K., Sadigh, D., and Zeng, A. Large language models as general pattern machines. arXiv preprint arXiv:2307.04721, 2023

    Pith/arXiv arXiv 2023

  46. [46]

    M., Keller, R

    Mitchell, T. M., Keller, R. M., and Kedar-Cabelli, S. T. Explanation-based generalization: A unifying view. Machine learning, 1: 0 47--80, 1986

    1986

  47. [47]

    Muennighoff, N., Rush, A., Barak, B., Le Scao, T., Tazi, N., Piktus, A., Pyysalo, S., Wolf, T., and Raffel, C. A. Scaling data-constrained language models. Advances in Neural Information Processing Systems, 36: 0 50358--50376, 2023

    2023

  48. [48]

    Semantic structure-mapping in llm and human analogical reasoning

    Musker, S., Duchnowski, A., Milli \`e re, R., and Pavlick, E. Semantic structure-mapping in llm and human analogical reasoning. arXiv preprint arXiv:2406.13803, 2024

    arXiv 2024

  49. [49]

    2 olmo 2 furious

    OLMo, T., Walsh, P., Soldaini, L., Groeneveld, D., Lo, K., Arora, S., Bhagia, A., Gu, Y., Huang, S., Jordan, M., et al. 2 olmo 2 furious. arXiv preprint arXiv:2501.00656, 2024

    Pith/arXiv arXiv 2024

  50. [50]

    Training language models to follow instructions with human feedback

    Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35: 0 27730--27744, 2022

    2022

  51. [51]

    and van der Plas, L

    Petersen, M. and van der Plas, L. Can language models learn analogical reasoning? investigating training objectives and comparisons to human performance. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp.\ 16414--16425, 2023

    2023

  52. [52]

    How does code pretraining affect language model task performance? In The 7th BlackboxNLP Workshop, 2024

    Petty, J., van Steenkiste, S., and Linzen, T. How does code pretraining affect language model task performance? In The 7th BlackboxNLP Workshop, 2024. URL https://openreview.net/forum?id=2sghJ1yYOr

    2024

  53. [53]

    Relevant or random: Can LLM s truly perform analogical reasoning? arXiv preprint arXiv:2404.12728, 2024

    Qin, C., Xia, W., Wang, T., Jiao, F., Hu, Y., Ding, B., Chen, R., and Joty, S. Relevant or random: Can LLM s truly perform analogical reasoning? arXiv preprint arXiv:2404.12728, 2024

    Pith/arXiv arXiv 2024

  54. [54]

    R., Talupuru, D., Locatelli, A., Kirk, R., Rockt \"a schel, T., Grefenstette, E., and Bartolo, M

    Ruis, L., Mozes, M., Bae, J., Kamalakara, S. R., Talupuru, D., Locatelli, A., Kirk, R., Rockt \"a schel, T., Grefenstette, E., and Bartolo, M. Procedural knowledge in pretraining drives reasoning in large language models. arXiv preprint arXiv:2411.12580, 2024

    Pith/arXiv arXiv 2024

  55. [55]

    and Wefald, E

    Russell, S. and Wefald, E. Principles of metareasoning. Artificial intelligence, 49 0 (1-3): 0 361--395, 1991

    1991

  56. [56]

    Can you learn an algorithm? generalizing from easy to hard problems with recurrent networks

    Schwarzschild, A., Borgnia, E., Gupta, A., Huang, F., Vishkin, U., Goldblum, M., and Goldstein, T. Can you learn an algorithm? generalizing from easy to hard problems with recurrent networks. Advances in Neural Information Processing Systems, 34: 0 6695--6706, 2021

    2021

  57. [57]

    Deepseekmath: Pushing the limits of mathematical reasoning in open language models

    Shao, Z., Wang, P., Zhu, Q., Xu, R., Song, J., Bi, X., Zhang, H., Zhang, M., Li, Y., Wu, Y., et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024

    Pith/arXiv arXiv 2024

  58. [58]

    Shepard, R. N. and Chang, J.-J. Stimulus generalization in the learning of classifications. Journal of Experimental Psychology, 65 0 (1): 0 94, 1963

    1963

  59. [59]

    J., Mehlhorn, K., and Borgwardt, K

    Shervashidze, N., Schweitzer, P., Van Leeuwen, E. J., Mehlhorn, K., and Borgwardt, K. M. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12 0 (9), 2011

    2011

  60. [60]

    Parallelparc: A scalable pipeline for generating natural-language analogies

    Sultan, O., Bitton, Y., Yosef, R., and Shahaf, D. Parallelparc: A scalable pipeline for generating natural-language analogies. In NAACL-HLT, 2024

    2024

  61. [61]

    Easy-to-hard generalization: Scalable alignment beyond human supervision

    Sun, Z., Yu, L., Shen, Y., Liu, W., Yang, Y., Welleck, S., and Gan, C. Easy-to-hard generalization: Scalable alignment beyond human supervision. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. URL https://openreview.net/forum?id=qwgfh2fTtN

    2024

  62. [62]

    Qwq-32b: Embracing the power of reinforcement learning, March 2025

    Team, Q. Qwq-32b: Embracing the power of reinforcement learning, March 2025. URL https://qwenlm.github.io/blog/qwq-32b/

    2025

  63. [63]

    Llama: Open and efficient foundation language models

    Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.-A., Lacroix, T., Rozi \`e re, B., Goyal, N., Hambro, E., Azhar, F., et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023

    Pith/arXiv arXiv 2023

  64. [64]

    and Kahneman, D

    Tversky, A. and Kahneman, D. Judgment under uncertainty: Heuristics and biases: Biases in judgments reveal some heuristics of thinking under uncertainty. science, 185 0 (4157): 0 1124--1131, 1974

    1974

  65. [65]

    Can language models solve graph problems in natural language? Advances in Neural Information Processing Systems, 36: 0 30840--30861, 2023

    Wang, H., Feng, S., He, T., Tan, Z., Han, X., and Tsvetkov, Y. Can language models solve graph problems in natural language? Advances in Neural Information Processing Systems, 36: 0 30840--30861, 2023

    2023

  66. [66]

    R., Zhang, S., Sun, Y., and Wang, W

    Wang, X., Hu, Z., Lu, P., Zhu, Y., Zhang, J., Subramaniam, S., Loomba, A. R., Zhang, S., Sun, Y., and Wang, W. Scibench: Evaluating college-level scientific problem-solving abilities of large language models. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=bq1JEgioLr

    2024

  67. [67]

    P lan G en LLM s: A modern survey of LLM planning capabilities

    Wei, H., Zhang, Z., He, S., Xia, T., Pan, S., and Liu, F. P lan G en LLM s: A modern survey of LLM planning capabilities. In Che, W., Nabende, J., Shutova, E., and Pilehvar, M. T. (eds.), Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp.\ 19497--19521, Vienna, Austria, July 2025. Associati...

    doi:10.18653/v1/2025.acl-long.958 2025

  68. [68]

    W., Lester, B., Du, N., Dai, A

    Wei, J., Bosma, M., Zhao, V., Guu, K., Yu, A. W., Lester, B., Du, N., Dai, A. M., and Le, Q. V. Finetuned language models are zero-shot learners. In International Conference on Learning Representations, 2022 a

    2022

  69. [69]

    V., Zhou, D., et al

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., Le, Q. V., Zhou, D., et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35: 0 24824--24837, 2022 b

    2022

  70. [70]

    Towards system 2 reasoning in LLM s: Learning how to think with meta chain-of-though

    Xiang, V., Snell, C., Gandhi, K., Albalak, A., Singh, A., Blagden, C., Phung, D., Rafailov, R., Lile, N., Mahan, D., et al. Towards system 2 reasoning in LLM s: Learning how to think with meta chain-of-though. arXiv preprint arXiv:2501.04682, 2025

    Pith/arXiv arXiv 2025

  71. [71]

    Qwen2.5 technical report

    Yang, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Li, C., Liu, D., Huang, F., Wei, H., Lin, H., Yang, J., Tu, J., Zhang, J., Yang, J., Yang, J., Zhou, J., Lin, J., Dang, K., Lu, K., Bao, K., Yang, K., Yu, L., Li, M., Xue, M., Zhang, P., Zhu, Q., Men, R., Lin, R., Li, T., Tang, T., Xia, T., Ren, X., Ren, X., Fan, Y., Su, Y., Zhang, Y., Wan, Y., Li...

    Pith/arXiv arXiv 2024

  72. [72]

    Emergent symbolic mechanisms support abstract reasoning in large language models

    Yang, Y., Campbell, D., Huang, K., Wang, M., Cohen, J., and Webb, T. Emergent symbolic mechanisms support abstract reasoning in large language models. arXiv preprint arXiv:2502.20332, 2025

    Pith/arXiv arXiv 2025

  73. [73]

    H., and Zhou, D

    Yasunaga, M., Chen, X., Li, Y., Pasupat, P., Leskovec, J., Liang, P., Chi, E. H., and Zhou, D. Large language models as analogical reasoners. arXiv preprint arXiv:2310.01714, 2023

    Pith/arXiv arXiv 2023

  74. [74]

    Language is all a graph needs

    Ye, R., Zhang, C., Wang, R., Xu, S., and Zhang, Y. Language is all a graph needs. In EACL (Findings), 2024

    2024

  75. [75]

    Limo: Less is more for reasoning

    Ye, Y., Huang, Z., Xiao, Y., Chern, E., Xia, S., and Liu, P. Limo: Less is more for reasoning. arXiv preprint arXiv:2502.03387, 2025

    Pith/arXiv arXiv 2025

  76. [76]

    Thought propagation: An analogical approach to complex reasoning with large language models

    Yu, J., He, R., and Ying, R. Thought propagation: An analogical approach to complex reasoning with large language models. arXiv preprint arXiv:2310.03965, 2023

    Pith/arXiv arXiv 2023

  77. [77]

    Beneath surface similarity: Large language models make reasonable scientific analogies after structure abduction

    Yuan, S., Chen, J., Ge, X., Xiao, Y., and Yang, D. Beneath surface similarity: Large language models make reasonable scientific analogies after structure abduction. In Findings of the Association for Computational Linguistics: EMNLP 2023, pp.\ 2446--2460, 2023 a

    2023

  78. [78]

    Analogykb: Unlocking analogical reasoning of language models with a million-scale knowledge base

    Yuan, S., Chen, J., Sun, C., Liang, J., Xiao, Y., and Yang, D. Analogykb: Unlocking analogical reasoning of language models with a million-scale knowledge base. arXiv preprint arXiv:2305.05994, 2023 b

    Pith/arXiv arXiv 2023

  79. [79]

    Star: Bootstrapping reasoning with reasoning

    Zelikman, E., Wu, Y., Mu, J., and Goodman, N. Star: Bootstrapping reasoning with reasoning. Advances in Neural Information Processing Systems, 35: 0 15476--15488, 2022

    2022

  80. [80]

    Z., Ye, X., Yang, X., Chen, L., Wang, W

    Zhang, X., Chen, Z. Z., Ye, X., Yang, X., Chen, L., Wang, W. Y., and Petzold, L. R. Unveiling the impact of coding data instruction fine-tuning on large language models reasoning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp.\ 25949--25957, 2025

    2025

Showing first 80 references.