Pith. sign in

REVIEW 4 major objections 5 minor 31 references

MetaRuleGPT: Recursive Numerical Reasoning of Language Models Trained with Simple Rules

T0 review · 4 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read MetaRuleGPT claims that a 30-million-parameter Transformer reaches 100 percent accuracy on high-digit arithmetic and 3D vector cross products by learning and composing simple rules.

desk verdict The 30M-parameter arithmetic claim rests on an underspecified verification loop and an internally inconsistent metrics table; the rule-learning idea is worth a second look, but the evidence as presented does not support the headline. read the letter →

arxiv 2412.13536 v1 pith:JYQAGUSE submitted 2024-12-18 cs.CL

Kejie Chen , Lin Wang , Qinghai Zhang , Renjun Xu This is my paper · ORCID
classification cs.CL
keywords MetaRuleGPTlearningrecursivereasoninghigh-digitarithmeticvectorcrossproductbyte-levelTransformermeta-learningnumerical
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

This paper claims that a language model can acquire exact numerical reasoning by learning and composing small, explicit rules instead of ingesting massive amounts of raw calculation examples. The authors present MetaRuleGPT, a 30-million-parameter byte-level Transformer pre-trained on roughly 20,000 records of basic, compound, and iterative arithmetic rules, and report 100 percent accuracy on 5- and 10-digit addition and subtraction and on three-dimensional vector cross products. These results are compared against much larger models such as GPT-4, GPT-3.5, PaLM, Qwen, and Llama2, which degrade as digit counts grow and score at or below 23 percent on vector cross products. If the claims hold, rule-structured pretraining would offer a parameter-efficient path to reliable arithmetic in language models, with the model decomposing hard problems into verified elementary steps.

What carries the argument

The load-bearing mechanism is the self-iteration loop composed of three parts: the pre-trained byte-level Transformer, RefeedFormatter, and VeriGate. The model starts from an expression like $78 + 263$ and transforms it through mapping rules into per-digit variables, aligns columns, applies a single-digit addition or subtraction table, propagates carries or borrows, and then formats the result; VeriGate checks whether the current decoding matches the expected structure of the previous decodings, and if not, RefeedFormatter realigns the token stream and the base model tries again. The vector cross-product task is handled by composing the learned arithmetic rules with a vector-product rule that reduces $(a,b,c)\times(d,e,f)$ to component-wise products such as $(bf-ce,\; cd-af,\; ae-bd)$, with signs from the right-hand rule. The same rule-composition machinery is what lets one 30-million-parameter model handle addition, subtraction, and cross products without retraining for each task.

What would settle it

Disable the VeriGate/RefeedFormatter loop and run the base 30-million-parameter model's raw decoding over the 8,000 test cases, especially 10-digit subtraction and vector cross products. If accuracy falls well below 100 percent while the full system stays at 100 percent, the perfect scores are produced by the verification harness rather than by rule knowledge learned in the weights; reporting that ablated accuracy would settle the claim.

Watch

Extended reading notes

Core claim

The central claim is that recursive rule application, not scale or example memorization, is what lets a Transformer do reliable mathematics. MetaRuleGPT is a byte-level Transformer taught from a compact dataset of arithmetic rules: digit mapping, column alignment, single-digit addition, subtraction, and multiplication tables, carry and borrow rules, a compute rule, and the vector-product rule. At inference the model repeatedly applies these rules, and a verification-and-formatting loop (VeriGate and RefeedFormatter) checks each decoding against the expected transformation of the recent decodings and feeds malformed outputs back for realignment. On the paper's 8,000-case test set, the model achieves 100 percent accuracy on 5- and 10-digit randomized addition and subtraction, including perfect-decadic, reverse-magnitude, and interleaved variants, and 100 percent on 3D vector cross products. The authors interpret this as evidence that the model has learned the underlying computational logic rather than specific instances.

Load-bearing premise

The perfect accuracy numbers rest on the assumption that the verification gate (VeriGate) can detect and correct rule-application mistakes using only the recent decoding history, without being handed the correct answer; if it instead checks against an answer already computed from the rules, the 100 percent scores reflect the harness rather than the model's learned arithmetic.

Editorial extensions

If this is right

  • A 30-million-parameter model can reach 100 percent accuracy on high-digit addition, subtraction, and 3D vector cross products, so for these narrow tasks scale is not the deciding factor.
  • Once addition and subtraction rules are mastered, adding the vector-product rule transfers to a new task without new arithmetic training, demonstrating multi-task generalization within one model.
  • Recursive self-iteration with a verification gate can replace unconstrained chain-of-thought generation, avoiding the arithmetic hallucination that the paper attributes to large models.
  • Compact rule datasets of about 20,000 records are sufficient training material for these tasks, which is far smaller than the raw-instance corpora used to train general large language models.
  • Because accuracy stays at 100 percent as digit length grows from 5 to 10, the model's behavior is consistent with having learned computational principles rather than memorized cases.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural next experiment is to disable VeriGate and measure the base model's raw decoding accuracy; if the perfect scores collapse, the verification loop is doing the arithmetic and the claim reduces to the claim that a small Transformer can format rule-based tokens.
  • The rule-composition scheme suggests an immediate test for generalization: train only on 5-digit addition rules and test on 20-digit inputs, or train on addition and subtraction but test on multiplication of large numbers; the paper does not report such out-of-distribution digit-length extrapolation.
  • Because the model is byte-level, the digit-token alignment is part of the rule machinery; comparing against a subword-tokenized version would isolate whether the byte encoding is responsible for the exact arithmetic.
  • If rule learning is as sample-efficient as reported, the same decomposition could be applied to symbolic integration or matrix operations, but the authors state in their limitations that function integration currently produces significant errors, so the transfer is not yet demonstrated.
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

4 major / 5 minor

Summary. MetaRuleGPT proposes a 30M-parameter Transformer pre-trained on small datasets of arithmetic rules (mapping, align, carry, borrow, compute) and combined with a RefeedFormatter/VeriGate self-iteration loop. The paper reports 100% accuracy on 5- and 10-digit addition, subtraction, and 3D vector cross-products, claiming to surpass GPT-4, GPT-3.5, Llama2, PaLM, Qwen, and Goat. It also reports comparisons on a simplified GSM8K subset. The central claims are that rule-based recursive decoding yields exact numerical computation and that this demonstrates generalization ability.

Significance. If established, the result would be notable: a 30M model attaining exact arithmetic where 100B+ models fail would suggest that rule-structured training data and iterative decoding are a strong inductive bias. The paper makes a useful pedagogical decomposition of arithmetic into rules, and the training set is small (about 20,000 records), which is a falsifiable design choice. However, as written, the significance is undercut by the underspecified verification loop, a metric inconsistency, and the circular relationship between training and test distributions. The paper would be strengthened by an ablation of the bare pretrained model and a precise statement of what VeriGate observes.

major comments (4)
  1. [III-C, Fig. 3] The load-bearing claim of 100% accuracy is not attributable to the 30M pretrained model because VeriGate and RefeedFormatter are unspecified. The text says VeriGate 'identifies whether the current decoding meets the expected transformation of the recent decodings' and RefeedFormatter 'realigns and adjusts the structure,' but it does not state what information VeriGate has, how it is trained (if at all), how many iterations are allowed, or what happens on repeated failure. If VeriGate compares the decoding to the correct transformation computed from arithmetic rules, then the reported accuracy is a property of a generate-and-check system with a rule oracle, not of the 30M model. An ablation of the pretrained model without VeriGate and RefeedFormatter, plus a precise specification of VeriGate's inputs and decision procedure, are necessary to support the abstract's claim.
  2. [IV-C, Table VII] The evaluation metrics are internally inconsistent. Under the definitions Accuracy = TP/N and DifferenceRatio = (1/N) * sum(|yi - yhat_i| / max(yi, yhat_i)), an accuracy of 100% implies every prediction is correct, so the difference ratio must be exactly 0. Table VII reports MetaRuleGPT on 10-digit randomized subtraction with Error 0.063 and Accuracy 100%, which is impossible under the paper's own definitions. This indicates either a data-reporting error or a different, unspecified computation of the difference ratio. Because the 100% claim is the centerpiece of the paper, this inconsistency must be resolved before the results can be trusted.
  3. [III-A, IV-B, Limitations] The evaluation is circular with respect to the generalization claim. The training data are generated from the same rule templates (mapping, carry, borrow, compute) that define the test distribution, and the paper's Limitations section explicitly states that the model 'cannot automatically handle untrained generalization forms or novel concepts beyond the meta-learning distribution.' The abstract and conclusion claim 'generalization ability' and 'transferable problem-solving skills,' but the experiments only test whether the model can follow the trained rule templates on in-distribution inputs. To support the generalization claim, the evaluation would need held-out rule combinations, task formats, or operand types not seen in training (for example, novel digit representations or unseen composite operations).
  4. [IV-D, Tables III-X, VIII] The comparison with baseline LLMs is not sufficiently controlled. There is no description of the prompting format, number of samples, temperature, or whether the baselines were allowed the same iterative VeriGate loop. Except for Goat, the baselines appear to be general-purpose LLMs, so the claim that MetaRuleGPT 'surpasses' them requires the same evaluation interface. In addition, Table VIII reports 100% for MetaRuleGPT on a simplified GSM8K subset without specifying which subset was used or how the natural-language problems were converted to formulas, making the result unreproducible. The table also omits accuracy values for two baseline models without explanation.
minor comments (5)
  1. [Fig. 2 caption] The notation '*' and '!' for 10 and 9 in the decimal representation is not introduced in the main text; please explain the encoding in the caption or in Section III.
  2. [Eq. (DifferenceRatio), Section IV-C] The difference-ratio formula uses i=0 in the sum but lists N terms; the index should start at 1, and the notation yi versus y_i should be made consistent throughout.
  3. [Tables IV-X] Several tables contain formatting artifacts, such as '2.1 0 .0%' in Table V and '0 .0%' in other rows; these spacing errors should be corrected.
  4. [Section V.A.2] The text says 'From the data in Table III' when discussing vector cross-product results, but the relevant comparison is in Table X; the cross-reference should be corrected.
  5. [References] Reference [20] is a plant biology paper and appears unrelated to rule-based reasoning in language models; please replace it with a relevant citation on rule-based or neuro-symbolic reasoning.

Circularity Check

1 steps flagged · score 7.0 of 10

MetaRuleGPT's 100% accuracy is produced by a VeriGate loop that accepts only decodings matching the expected rule transformation; the bare 30M model is never evaluated, so the central result reduces to the verifier.

  1. self definitional [Section III-C and Fig. 3 caption; Section III-E step 5; Fig. 6 caption]
    "VeriGate is used to identify whether the current decoding meets the expected transformation of the recent decodings. If it does not meet the expectations, it will enter RefeedFormatter to realign and adjust the structure and then use the basic rules of the model again. According to the operation rules, after a limited number of calls to the basic rule model, the final output is obtained."

    The central claim is that the 30M-parameter model achieves 100% on high-digit arithmetic and vector cross-products. The paper's only description of inference says a decoding is accepted only if it 'meets the expected transformation' under the operation rules, otherwise the structure is adjusted and the model is called again. By the paper's own description, VeriGate identifies whether the decoding meets the expected transformation; a decoding that passes is rule-correct by construction, independently of whether the model learned the rules. The paper never reports the accuracy of the MetaRuleGPT pre-trained model without the VeriGate/RefeedFormatter loop, so the 100% figure in Tables III-X measures the generate-and-check wrapper, not the learned model. Fig.

full rationale

The strongest circular step is the evaluation harness. The paper defines the final answer as the decoding that satisfies VeriGate's 'expected transformation' of the recent decodings; since that expected transformation is computed 'according to the operation rules', the output is guaranteed to match the rule-defined answer before it is reported. The claimed prediction therefore reduces by construction to the verifier, and the 30M model's independent rule-following ability is never measured. This is compounded by an internal inconsistency: Table VII reports Error 0.063 together with Accuracy 100% for 10-digit randomized subtraction, which is impossible under the paper's own definitions, since any nonzero mean difference ratio implies at least one incorrect prediction. The fact that training and test data are generated from the same rule templates is not itself circular, because the test cases are non-overlapping and the model could in principle fail to apply the rules; this supports only an in-distribution generalization claim, and the limitations section concedes the model 'cannot automatically handle untrained generalization forms or novel concepts beyond the meta-learning distribution'. There is no load-bearing self-citation chain. The central defect is that the 100% accuracy result is produced by a loop that selects for outputs matching the expected rule transformation, so the headline claim is not an independent property of the trained Transformer.

Assumptions & free parameters 3 free parameters · 4 assumptions · 2 invented entities

The 100% accuracy claim rests on the rule dataset generation, the byte-level Transformer's ability to learn and compose those rules, and the unspecified VeriGate/RefeedFormatter loop. The model weights, dataset composition, and loop configuration are all fitted or chosen by hand, and none are released, so the ledger is heavy.

free parameters (3)
  • Transformer model parameters (30M total) = not reported per-component
    The model's weights are fit to the rule dataset; without layer count, hidden size, or training loss, the capacity actually used for rule execution is unspecified.
  • Rule dataset size and composition = ~20,000 records
    The dataset size is chosen without a scaling or ablation analysis, yet the 100% generalization claim depends on it.
  • VeriGate/RefeedFormatter loop configuration = not specified
    No thresholds, stopping criteria, or correction rules are given; the loop is load-bearing for the reported accuracy.
assumptions (4)
  • standard math Standard positional digit algorithms for carry and borrow are correct and sufficient for all test cases.
    Invoked in Section III-A when carry/borrow rules are trained and applied to 10-digit numbers.
  • domain assumption The byte-level tokenizer preserves digit and sign alignment required by the mapping and align rules.
    Section III-D states single-byte training is used; no analysis shows this tokenizer is sufficient for the iterative rule format.
  • domain assumption The ~20,000-record rule dataset covers all rule combinations needed for arbitrary high-digit inputs and vector cross products.
    Section III-B describes the dataset; no coverage proof or generation procedure is given, and limitation 3 concedes untrained forms fail.
  • ad hoc to paper VeriGate can detect whether a decoding matches the expected transformation without access to the ground-truth answer, and RefeedFormatter can repair misaligned decodings.
    Section III-C, Fig 3: this mechanism is introduced for this paper; no implementation details or correctness argument are provided.
invented entities (2)
  • VeriGate
    purpose: Checks each decoding against the expected transformation and triggers reformatting when the output does not match expectations.
    The paper gives only a diagram and a one-sentence description (Section III-C); no code, thresholds, or correctness proof are provided, so there is no externally checkable handle.
  • RefeedFormatter
    purpose: Realigns and adjusts the structure of intermediate outputs before re-feeding them to the pretrained model.
    Described only in Fig 3 and Section III-C; the exact transformation rules are not specified, making the 100% accuracy unreproducible.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MetaRuleGPT: Recursive Numerical Reasoning of Language Models Trained with Simple Rules." pith.science (2026). https://pith.science/paper/JYQAGUSE

@misc{pith2026241213536,
  author       = {Pith},
  title        = {Pith review of: MetaRuleGPT: Recursive Numerical Reasoning of Language Models Trained with Simple Rules},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JYQAGUSE}},
  note         = {Machine review of arXiv:2412.13536}
}
read the original abstract

Recent studies have highlighted the limitations of large language models in mathematical reasoning, particularly their inability to capture the underlying logic. Inspired by meta-learning, we propose that models should acquire not only task-specific knowledge but also transferable problem-solving skills. We introduce MetaRuleGPT, a novel Transformer-based architecture that performs precise numerical calculations and complex logical operations by learning and combining different rules. In contrast with traditional training sets, which are heavily composed of massive raw instance data, MetaRuleGPT is pre-trained on much less abstract datasets containing basic, compound, and iterative rules for mathematical reasoning. Extensive experimental results demonstrate MetaRuleGPT can mimic human's rule-following capabilities, break down complexity, and iteratively derive accurate results for complex mathematical problems. These findings prove the potential of rule learning to enhance the numerical reasoning abilities of language models.

Figures

Figures reproduced from arXiv: 2412.13536 by the authors.

Figure 1
Figure 1. This image illustrates the differences between MetaRuleGPT and the traditional Chain-of-Thought (CoT) reasoning method in handling mathematical [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. This picture shows some training rule examples, where * and ! [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. This figure shows Architecture Diagram of MetaRuleGPT. [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: MetaRuleGPT Pre-trained Model. SAN represents Self-Attention [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: MetaRuleGPT language model calculation example diagram [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Comparison of the accuracy of addition and subtraction of GPT4, [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 6 canonical work pages

  1. [28]

    Goat: Fine-tuned llama outperforms gpt-4 on arithmetic tasks,

    T. Liu and B. K. H. Low, “Goat: Fine-tuned llama outperforms gpt-4 on arithmetic tasks,” 2023. [Online]. Available: https://arxiv.org/abs/ 2305.14201

    arXiv 2023

  2. [1]

    Benchmarking large language models’ performances for myopia care: a comparative analysis of chatgpt-3.5, chatgpt-4.0, and google bard,

    Z. W. Lim, K. Pushpanathan, S. M. E. Yew, Y . Lai, C.-H. Sun, J. S. H. Lam, D. Z. Chen, J. H. L. Goh, M. C. J. Tan, B. Sheng et al. , “Benchmarking large language models’ performances for myopia care: a comparative analysis of chatgpt-3.5, chatgpt-4.0, and google bard,” EBioMedicine, vol. 95, 2023

    work page 2023

  3. [2]

    TL;DR: Mining Reddit to learn automatic summarization,

    M. V ¨olske, M. Potthast, S. Syed, and B. Stein, “TL;DR: Mining Reddit to learn automatic summarization,” in Proceedings of the Workshop on New Frontiers in Summarization , L. Wang, J. C. K. Cheung, G. Carenini, and F. Liu, Eds. Copenhagen, Denmark: Association for Computational Linguistics, Sep. 2017, pp. 59–63. [Online]. Available: https://aclanthology....

    work page 2017

  4. [3]

    Teaching machines to read and comprehend,

    K. M. Hermann, T. Ko ˇcisk´y, E. Grefenstette, L. Espeholt, W. Kay, M. Suleyman, and P. Blunsom, “Teaching machines to read and comprehend,” 2015. [Online]. Available: https://arxiv.org/abs/1506. 03340

    work page 2015

  5. [4]

    Don’t give me the details, just the summary! topic-aware convolutional neural networks for extreme summarization,

    S. Narayan, S. B. Cohen, and M. Lapata, “Don’t give me the details, just the summary! topic-aware convolutional neural networks for extreme summarization,” 2018. [Online]. Available: https://arxiv.org/abs/1808.08745

    arXiv 2018

  6. [5]

    Piqa: Reasoning about physical commonsense in natural language,

    Y . Bisk, R. Zellers, R. L. Bras, J. Gao, and Y . Choi, “Piqa: Reasoning about physical commonsense in natural language,” 2019. [Online]. Available: https://arxiv.org/abs/1911.11641

    arXiv 2019

  7. [6]

    Measuring massive multitask language understanding,

    D. Hendrycks, C. Burns, S. Basart, A. Zou, M. Mazeika, D. Song, and J. Steinhardt, “Measuring massive multitask language understanding,”

  8. [7]

    Metamath: Bootstrap your own mathematical questions for large language models,

    L. Yu, W. Jiang, H. Shi, J. Yu, Z. Liu, Y . Zhang, J. T. Kwok, Z. Li, A. Weller, and W. Liu, “Metamath: Bootstrap your own mathematical questions for large language models,” 2024. [Online]. Available: https://arxiv.org/abs/2309.12284

    arXiv 2024

Show all 31 references
  1. [8]

    Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instruct,

    H. Luo, Q. Sun, C. Xu, P. Zhao, J. Lou, C. Tao, X. Geng, Q. Lin, S. Chen, and D. Zhang, “Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instruct,” 2023. [Online]. Available: https://arxiv.org/abs/2308.09583

    2023 arXiv

  2. [9]

    Math-shepherd: Verify and reinforce llms step-by-step without human annotations,

    P. Wang, L. Li, Z. Shao, R. X. Xu, D. Dai, Y . Li, D. Chen, Y . Wu, and Z. Sui, “Math-shepherd: Verify and reinforce llms step-by-step without human annotations,” 2024. [Online]. Available: https://arxiv.org/abs/2312.08935

    2024 arXiv

  3. [10]

    Chain-of-thought prompting elicits reasoning in large language models,

    J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. Chi, Q. Le, and D. Zhou, “Chain-of-thought prompting elicits reasoning in large language models,” 2023. [Online]. Available: https://arxiv.org/abs/2201.11903

    2023 arXiv

  4. [11]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in neural information processing systems , vol. 30, 2017

    2017

  5. [13]

    Language mod- els are few-shot learners,

    T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell et al., “Language mod- els are few-shot learners,” Advances in neural information processing systems, vol. 33, pp. 1877–1901, 2020

    1901

  6. [14]

    Least-to- most prompting enables complex reasoning in large language models,

    D. Zhou, N. Sch ¨arli, L. Hou, J. Wei, N. Scales, X. Wang, D. Schuurmans, C. Cui, O. Bousquet, Q. Le, and E. Chi, “Least-to- most prompting enables complex reasoning in large language models,”

  7. [15]

    Complexity- based prompting for multi-step reasoning,

    Y . Fu, H. Peng, A. Sabharwal, P. Clark, and T. Khot, “Complexity- based prompting for multi-step reasoning,” 2023. [Online]. Available: https://arxiv.org/abs/2210.00720

    2023 arXiv

  8. [16]

    Self-consistency improves chain of thought reasoning in language models,

    X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou, “Self-consistency improves chain of thought reasoning in language models,” 2023. [Online]. Available: https://arxiv.org/abs/2203.11171

    2023 arXiv

  9. [17]

    Finetuned language models are zero-shot learners,

    J. Wei, M. Bosma, V . Y . Zhao, K. Guu, A. W. Yu, B. Lester, N. Du, A. M. Dai, and Q. V . Le, “Finetuned language models are zero-shot learners,” 2022. [Online]. Available: https://arxiv.org/abs/2109.01652

    2022 arXiv

  10. [18]

    Meta-learning: A survey,

    J. Vanschoren, “Meta-learning: A survey,” 2018. [Online]. Available: https://arxiv.org/abs/1810.03548

    2018 arXiv

  11. [19]

    Model-agnostic meta-learning for fast adaptation of deep networks,

    C. Finn, P. Abbeel, and S. Levine, “Model-agnostic meta-learning for fast adaptation of deep networks,” 2017. [Online]. Available: https://arxiv.org/abs/1703.03400

    2017 arXiv

  12. [20]

    Functional Network Construction in Arabidopsis Using Rule-Based Machine Learning on Large-Scale Data Sets ,

    G. W. Bassel, E. Glaab, J. Marquez, M. J. Holdsworth, and J. Bacardit, “Functional Network Construction in Arabidopsis Using Rule-Based Machine Learning on Large-Scale Data Sets ,” The Plant Cell, vol. 23, no. 9, pp. 3101–3116, 09 2011. [Online]. Available: https://doi.org/10....

    2011 doi

  13. [21]

    Ernie: En- hanced language representation with informative entities,

    Z. Zhang, X. Han, Z. Liu, X. Jiang, M. Sun, and Q. Liu, “Ernie: En- hanced language representation with informative entities,”arXiv preprint arXiv:1905.07129, 2019

    1905 arXiv

  14. [22]

    Human-like systematic generalization through a meta-learning neural network,

    B. M. Lake and M. Baroni, “Human-like systematic generalization through a meta-learning neural network,” Nature, vol. 623, no. 7985, pp. 115–121, 2023

    2023

  15. [23]

    OpenAI’s ChatGPT: A Revolution in Language AI,

    OpenAI, “OpenAI’s ChatGPT: A Revolution in Language AI,” https: //openai.com/blog/chat-gpt/, Sep. 2021

    2021

  16. [24]

    Qwen technical report,

    J. Bai, S. Bai, Y . Chu, Z. Cui, K. Dang, X. Deng, Y . Fan, W. Ge, Y . Han, F. Huang et al. , “Qwen technical report,” arXiv preprint arXiv:2309.16609, 2023

    2023 arXiv

  17. [25]

    Palm 2 technical report,

    R. Anil, A. M. Dai, O. Firat, M. Johnson, D. Lepikhin, A. Passos, S. Shakeri, E. Taropa, P. Bailey, Z. Chenet al., “Palm 2 technical report,” arXiv preprint arXiv:2305.10403 , 2023

    2023 arXiv

  18. [26]

    Palm: Scal- ing language modeling with pathways,

    A. Chowdhery, S. Narang, J. Devlin, M. Bosma, G. Mishra, A. Roberts, P. Barham, H. W. Chung, C. Sutton, S. Gehrmann et al., “Palm: Scal- ing language modeling with pathways,” Journal of Machine Learning Research, vol. 24, no. 240, pp. 1–113, 2023

    2023

  19. [27]

    Llama 2: Open foundation and fine-tuned chat models,

    H. Touvron, L. Martin, K. Stone, P. Albert, A. Almahairi, Y . Babaei, N. Bashlykov, S. Batra, P. Bhargava, S. Bhosale et al. , “Llama 2: Open foundation and fine-tuned chat models,” arXiv preprint arXiv:2307.09288, 2023

    2023 arXiv

  20. [29]

    Recursion of thought: A divide-and-conquer approach to multi-context reasoning with language models,

    S. Lee and G. Kim, “Recursion of thought: A divide-and-conquer approach to multi-context reasoning with language models,” 2023. [Online]. Available: https://arxiv.org/abs/2306.06891

    2023 arXiv

  21. [30]

    Training verifiers to solve math word problems,

    K. Cobbe, V . Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schul- man, “Training verifiers to solve math word problems,” arXiv preprint arXiv:2110.14168, 2021

    arXiv

  22. [2021]

    Available: https://arxiv.org/abs/2009.03300

    [Online]. Available: https://arxiv.org/abs/2009.03300

    2009 arXiv

  23. [2023]

    Available: https://arxiv.org/abs/2205.10625

    [Online]. Available: https://arxiv.org/abs/2205.10625

    arXiv

Pith tools

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