Pith. sign in

REVIEW 5 major objections 4 minor 28 references

Dspy-based Neural-Symbolic Pipeline to Enhance Spatial Reasoning in LLMs

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

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

Pith's one-line read A neural-symbolic pipeline with solver feedback achieves 82% on StepGame and 69% on SparQA.

desk verdict A plausible but under-documented system result: DSPy-orchestrated LLM+ASP beats direct prompting on two spatial benchmarks, yet the evaluation lacks artifacts and a clear data split, so the exact numbers shouldn't be trusted yet. read the letter →

arxiv 2411.18564 v2 pith:Y3HTHTBD submitted 2024-11-27 cs.AI cs.CL

Rong Wang , Kun Sun , Jonas Kuhn This is my paper · ORCID
classification cs.AIcs.CL
keywords spatialreasoningneural-symbolicAnswerSetProgrammingDSPyiterativefeedbacklargelanguagemodelsStepGameSparQA
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 sets out to show that spatial reasoning in large language models can be substantially improved by pairing the model with a symbolic solver and letting the two exchange information. The authors build a DSPy-orchestrated pipeline in which an LLM translates spatial-language descriptions into Answer Set Programming facts and rules, the Clingo solver reasons over them, and solver error messages are fed back to the LLM to refine the formal program over up to three iterations. Across three LLM architectures (Deepseek, Llama3, and GPT-4.0 mini) the pipeline averages 82% accuracy on StepGame and 69% on SparQA, compared with roughly 30% and 57% for direct prompting. The paper argues that the gains come from separating semantic parsing from logical deduction, from the iterative repair loop that raises the share of executable ASP programs, and from explicit handling of parsing, grounding, and solving failures.

What carries the argument

The load-bearing mechanism is the iterative feedback loop between the LLM and the ASP solver, embedded in a DSPy pipeline. DSPy, a Python framework that compiles declarative LLM calls into self-improving pipelines, orchestrates four stages: fact generation (LLM produces ASP facts and a query), program refinement (LLM edits the ASP over up to three rounds using solver diagnostics), symbolic reasoning (the Clingo solver computes stable models), and answer mapping (solver output is matched to candidates via a synonym dictionary). The loop matters because LLMs often generate syntactically invalid or ungroundable ASP; feeding solver errors back lets the LLM repair its own program, which is what raises executability and accuracy.

What would settle it

Take a random sample of StepGame instances, hand-correct the labels, and recompute accuracy against the corrected gold standard. If the LLM+ASP advantage over direct prompting largely disappears, the central claim fails.

Watch

Extended reading notes

Core claim

The central claim is that a modular neural-symbolic pipeline, where an LLM writes ASP code and a solver's diagnostics drive iterative repair, reliably outperforms direct prompting and a lighter natural-language 'Facts+Rules' strategy on spatial reasoning benchmarks. The reported numbers: average 82% accuracy on StepGame (87.7% for Deepseek, 75.6% for Llama3, 80.8% for GPT-4.0 mini) and 69% on SparQA, with StepGame gains of roughly 40–50 percentage points over direct prompting. The authors attribute the improvement to three mechanisms: modular separation of parsing from reasoning, iterative feedback that raises the proportion of executable ASP programs, and targeted error handling for parsing, grounding, and solving failures. On SparQA the feedback loop alone lifts program execution rates from roughly 35–46% to 73–80% and accuracy from 24–42% to 70–72% across the three models.

Load-bearing premise

The reported accuracies and improvements assume the benchmark labels are correct, but the paper itself finds that about 10% of StepGame instances carry labeling errors.

Editorial extensions

If this is right

  • Across all three tested LLM architectures, the LLM+ASP pipeline beats both direct prompting and Facts+Rules on StepGame at every reasoning depth from 1 to 10 hops.
  • On SparQA, the iterative feedback loop raises ASP program execution rates from roughly 35–46% to 73–80% and accuracy from 24–42% to 70–72%, showing the loop is the main driver of the gain.
  • Facts+Rules, which applies the same logical rules inside natural-language prompts, reaches accuracy close to the full LLM+ASP pipeline on SparQA while avoiding solver and code-generation overhead.
  • The pipeline also functions as a dataset-quality checker, identifying about 10% labeling errors in StepGame instances, consistent with earlier findings.
  • The consistency of gains across Deepseek, Llama3, and GPT-4.0 mini suggests the mechanism transfers across LLM families, not just to one model.

Reading between the lines

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

  • Because the paper itself reports roughly 10% labeling errors in StepGame, some measured accuracy may reflect agreement with wrong labels; correcting those labels could shrink the reported gap to baselines. This is our inference, not the paper's claim.
  • The same LLM-plus-solver feedback design could transfer to other structured reasoning tasks—temporal reasoning, planning, constraint satisfaction—wherever the bottleneck is producing executable formal code from natural language.
  • The error taxonomy suggests model-specific tuning matters: Deepseek's syntax errors, GPT-4.0 mini's predicate-argument ordering, and Llama3's satisfiability failures each need different prompts or validation rules, so a single fixed pipeline may underperform on new models.
  • Since Facts+Rules nearly matches the full ASP pipeline on SparQA, the added value of formal code generation appears task-dependent; a cost-aware system might choose the lighter method for language-heavy questions and reserve ASP for multi-hop chain reasoning.
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

5 major / 4 minor

Summary. The paper proposes a neural-symbolic pipeline for spatial reasoning in LLMs. The pipeline uses DSPy to structure LLM calls that convert natural-language context and questions into Answer Set Programming (ASP) facts and queries, iteratively refines the ASP program using solver error feedback, and then evaluates the solver output against a synonym dictionary. The authors compare three strategies—direct prompting, Facts+Rules prompting, and the DSPy-based LLM+ASP pipeline—on StepGame and SparQA, using DeepSeek, Llama3, and GPT-4.0 mini. They report that the LLM+ASP pipeline substantially outperforms direct prompting on StepGame, with smaller gains on SparQA, and they include an ablation of the iterative feedback loop. The central claim is that separating semantic parsing from symbolic reasoning and adding iterative solver feedback yields large, generalizable improvements over direct prompting.

Significance. If the reported gains are robust, the paper would make a useful empirical contribution to neural-symbolic integration for spatial reasoning. The strengths are the comparison across three different LLMs and two quite different benchmarks, the inclusion of a lightweight Facts+Rules intermediate method, and the explicit analysis of feedback-loop effects on program executability. However, the paper currently does not ship code, prompts, or a clear description of the data used for DSPy optimization, and the quantitative claims are internally inconsistent across the abstract, introduction, tables, and conclusion. The significance is therefore conditional on resolving these verification and reproducibility issues; the qualitative direction of the results is plausible, but the specific numbers and the generalizability claim are not yet established.

major comments (5)
  1. [§3.2, §4.1.1, §4.2.1] The paper never specifies which data were used by DSPy's optimizer to compile and refine prompts, although §3.2 says that the optimizer 'iteratively generates and refines prompts' and 'optimizes LLM prompts and weights.' The evaluation sections describe only the construction of the test samples (300 per StepGame hop; 220 hand-selected SparQA examples). If the DSPy compilation used the same instances that are later scored, the reported gains over the non-optimized Direct baseline would be inflated by test-set overfitting. Please specify the disjoint training/validation split used for DSPy optimization, and if the optimizer was run on the evaluation instances, report results with prompts frozen on truly held-out data.
  2. [Abstract, §1, §5, Table 1, Table 2, §4.3] The central quantitative claims are internally inconsistent. The DSPy overall accuracies in Table 1 are 87.7%, 75.6%, and 80.8%, whose mean is 81.4%, not the abstract's 82%. Section 5 cites 'StepGame (92%) and SparQA (65%)', which appear in no table. Section 4.3 reports final feedback-loop accuracies of 70.5%, 71.8%, and 70.9% for DeepSeek, Llama3, and GPT-4.0 mini, which differ from the Table 2 overall accuracies of 67.2%, 69.4%, and 70.3%. The introduction's claim of '40% on StepGame and 20% on SparQA' also conflicts with the abstract and conclusion's '40-50% and 8-15%.' These discrepancies need to be reconciled before the quantitative claims can be taken at face value.
  3. [§4.1.3, §3.1] The paper reports that about 10% of StepGame instances have labeling errors and that these ambiguities accumulate with reasoning depth, yet all reported StepGame accuracies in Table 1 are computed against the original labels without correction or sensitivity analysis. Because the abstract's headline results are absolute accuracy values (82% on StepGame) and improvements of 40-50% over direct prompting, a label-error rate of about 10% could materially shift the absolute numbers. Please evaluate on a cleaned subset, quantify the sensitivity of each method to label noise, or clearly caveat the absolute accuracy figures.
  4. [§4.2.1, §4.2.2] The SparQA evaluation is based on a hand-selected subset of 220 examples (55 per question type), and the relation rules are described as 'manually designed and updated' for this dataset, while the StepGame knowledge module is adapted from Yang et al. (2023b). With no error bars or significance tests, the reported 8-15% improvement over direct prompting on SparQA could lie within sampling noise, and the manual per-dataset rule engineering weakens the paper's generalizability claim. Please report confidence intervals or significance tests, justify the representativeness of the 220-example selection, and document the degree to which the gains depend on the manually engineered rules.
  5. [§3.2, §4.2.1] The manuscript refers to an appendix for 'code and samples' and repeatedly relies on prompt-engineering details, but no code, prompts, or sample outputs are provided in the text and no repository link is given. Since the method's contribution is a specific DSPy pipeline with iterative feedback and error handling, the absence of these artifacts prevents verification and replication. Please include the full prompts, the DSPy program, the ASP rule sets, and the evaluation scripts, or provide a persistent public repository.
minor comments (4)
  1. [§3.2, Figure 1] The figure numbering is inconsistent: the caption says 'Figure 1: LLM +ASP Pipeline' while the text says 'The framework of this pipeline is shown in Fig.2.' Please unify the figure references and ensure the figure is actually included.
  2. [§3.3] The description of the direct prompting baseline contains a duplicated sentence: 'As the most straightforward approach, it involves presenting the task to the LLM without additional guidance. ... This straightforward approach involves presenting the task to the LLM without additional guidance.' Please remove the repetition.
  3. [§1, References] The introduction cites '(Yu et al, 2021)' but this reference is missing from the reference list; please add the full citation or remove the citation.
  4. [Throughout] There are numerous typos and grammatical errors, including 'collpase' (§2.2), 'satifiable' (§4.2.3), 'overr' (§4.2.2), 'I If' (§4.2.2), 'perforamce' and 'pipleine' (§5), and 'liketree of thoughts' (§2.1). A thorough proofreading pass is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper reports empirical benchmark comparisons with external datasets and independent baselines; the DSPy optimization-split concern is a reproducibility risk, not a provable circularity.

full rationale

The paper's central claims are empirical accuracy comparisons on externally defined benchmarks (StepGame and SparQA) against independent baselines (direct prompting and Facts+Rules). There is no formal derivation chain in which an output quantity is defined in terms of the quantity it is said to predict. The StepGame reasoning rules are adapted from Yang et al. (2023b), an external prior work, and those rules encode general coordinate-based spatial reasoning rather than the benchmark labels themselves; the LLM still must extract facts correctly, so the reported accuracy is not forced by construction. The SparQA rules are described as manually designed and updated, which raises a legitimate concern about possible tuning to the test set, but the paper does not state that evaluation labels were used to fit the rules or the DSPy prompts, so this is an experimental-validity risk rather than a demonstrated circular step. Numerical inconsistencies (e.g., the abstract's 82% vs. the table average of 81.4%, and the conclusion's StepGame (92%) and SparQA (65%) not matching any table) are internal-consistency and reporting issues, not circular reasoning. No load-bearing self-citations or imported uniqueness theorems appear. Therefore the paper receives a circularity score of 0.

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

The paper makes no formal claim; it reports empirical system performance. Its results rest on benchmark-specific manual rules, an undocumented evaluation subset design, and an unstated assumption about how DSPy optimization was split, all of which are external to the claimed finding.

free parameters (5)
  • Feedback iteration limit = 3
    The pipeline stops after three refinement rounds to cap cost (sections 3.2 and 4.3). The feedback-ablation analysis shows most gains come in round one, so this cap affects reported accuracy.
  • StepGame evaluation sample per hop = 300 per hop (3,000 total per model)
    Sampled from 10,000 per hop (section 4.1.1); sampling is said to be comprehensive but no seeds or random procedure are given, so variance cannot be assessed.
  • SparQA evaluation subset = 220 examples (55 per question type)
    Hand-constructed representative set (section 4.2.1); no random selection or seed, so results may not generalize to the full benchmark.
  • SparQA relation rules = Manually designed inverse, transitive, and symmetric rules
    Rules were manually designed and updated per dataset (section 4.2.1); these encode the semantics being tested and are benchmark-specific.
  • StepGame knowledge module cardinal offsets = Coordinate offsets adapted from Yang et al. (2023b)
    The coordinate-based reasoning rules treat one object as the origin and apply cardinal offsets (section 4.1.1); these are imported constants, not derived in this paper.
assumptions (4)
  • domain assumption ASP stable model semantics correctly formalizes the spatial relations in StepGame and SparQA.
    The pipeline's output is only as valid as the mapping from natural language relations to the predicate and rule vocabulary in sections 2.3 and 3.2, which is adopted, not derived here.
  • domain assumption The benchmark ground-truth labels are accurate enough to score against.
    Accuracy is computed against those labels, but section 4.1.3 reports about 10% labeling errors in StepGame, which weakens this premise.
  • ad hoc to paper DSPy prompt and weight optimization was performed on a training or validation split, not on the reported test set.
    Section 3.2 says DSPy iteratively refines prompts and weights but never states which examples are used, so the reported numbers may include leakage.
  • domain assumption After up to three refinement rounds, the LLM-generated ASP programs faithfully encode the natural language input.
    Section 4.2.3 lists 'satisfiable but no result' and wrong-answer errors caused by semantic gaps between language and logic, so faithfulness is only approximate.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Dspy-based Neural-Symbolic Pipeline to Enhance Spatial Reasoning in LLMs." pith.science (2026). https://pith.science/paper/Y3HTHTBD

@misc{pith2026241118564,
  author       = {Pith},
  title        = {Pith review of: Dspy-based Neural-Symbolic Pipeline to Enhance Spatial Reasoning in LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y3HTHTBD}},
  note         = {Machine review of arXiv:2411.18564}
}
read the original abstract

Large Language Models (LLMs) have demonstrated remarkable capabilities across various tasks, yet they often struggle with spatial reasoning. This paper presents a novel neural-symbolic framework that enhances LLMs' spatial reasoning abilities through iterative feedback between LLMs and Answer Set Programming (ASP). We evaluate our approach on two benchmark datasets: StepGame and SparQA, implementing three distinct strategies: (1) direct prompting baseline, (2) Facts+Rules prompting, and (3) DSPy-based LLM+ASP pipeline with iterative refinement. Our experimental results demonstrate that the LLM+ASP pipeline significantly outperforms baseline methods, achieving an average 82% accuracy on StepGame and 69% on SparQA, marking improvements of 40-50% and 8-15% respectively over direct prompting. The success stems from three key innovations: (1) effective separation of semantic parsing and logical reasoning through a modular pipeline, (2) iterative feedback mechanism between LLMs and ASP solvers that improves program rate, and (3) robust error handling that addresses parsing, grounding, and solving failures. Additionally, we propose Facts+Rules as a lightweight alternative that achieves comparable performance on complex SparQA dataset, while reducing computational overhead.Our analysis across different LLM architectures (Deepseek, Llama3-70B, GPT-4.0 mini) demonstrates the framework's generalizability and provides insights into the trade-offs between implementation complexity and reasoning capability, contributing to the development of more interpretable and reliable AI systems.

Figures

Figures reproduced from arXiv: 2411.18564 by the authors.

Figure 1
Figure 1. LLM +ASP Pipeline Inspired by Pan et al. (2023)’s LOGIC-LM framework and integration neural-symbolic strategies, we propose a novel neural-symbolic pipeline em￾ploying ASP using DSPy that treats the LLM as an agent capable of feedback and iteration. DSPy is a Python framework that uses a declarative and self￾improving approach to simplify working with LLMs (Khattab et al., 2023). It automates the optimization of pro… view at source ↗
Figure 2
Figure 2. Effects of Feedback Loop between LLM and ASP on the SparQA [PITH_FULL_IMAGE:figures/full_fig_p017_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

28 extracted references · 12 canonical work pages

  1. [1]

    A multitask, multilingual, multimodal evaluation of ChatGPT on reasoning, hallucination, and interactivity

    Bang, Y., Cahyawijaya, S., Lee, N., Dai, W., Su, D., Wilie, B., Lovenia, H., Ji, Z., Yu, T., Chung, W., and others (2023). A multitask, multilingual, multimodal evaluation of ChatGPT on reasoning, hallucination, and interactivity. In Proceedings of the 13th international joint conference on natural language processing and the 3rd conference of the asia-pa...

    work page 2023

  2. [2]

    R., d’Avila Garcez, A., Bader, S., Bowman, H., Domingos, P., Hitzler, P., Kühnberger, K.-U., Lamb, L

    Besold, T. R., d’Avila Garcez, A., Bader, S., Bowman, H., Domingos, P., Hitzler, P., Kühnberger, K.-U., Lamb, L. C., Lima, P. M. V., de Penning, L., and others (2021). Neural-symbolic learning and reasoning: A survey and interpretation 1. In Neuro-symbolic artificial intelligence: The state of the art , pages 1--51. IOS press

    work page 2021

  3. [3]

    Brewka, G., Eiter, T., and Truszczy \'n ski, M. (2011). Answer set programming at a glance. Communications of the ACM , 54(12):92--103

    work page 2011

  4. [4]

    Chu, Z., Chen, J., Chen, Q., Yu, W., He, T., Wang, H., Peng, W., Liu, M., Qin, B., and Liu, T. (2023). A survey of chain of thought reasoning: Advances , frontiers and future. ArXiv , abs/2309.15402

    arXiv 2023

  5. [5]

    Cohn, A. G. (2023). An evaluation of ChatGPT -4's qualitative spatial reasoning capabilities in RCC -8. arXiv preprint arXiv:2309.15577

    arXiv 2023

  6. [6]

    Eiter, T., Higuera, N., Oetsch, J., and Pritz, M. (2022). A neuro-symbolic ASP pipeline for visual question answering. Theory and Practice of Logic Programming , 22(5):739--754. Publisher: Cambridge University Press

    work page 2022

  7. [7]

    Fang, M., Deng, S., Zhang, Y., Shi, Z., Chen, L., Pechenizkiy, M., and Wang, J. (2024). Large language models are neurosymbolic reasoners. In Proceedings of the AAAI conference on artificial intelligence , volume 38, pages 17985--17993. Number: 16

    work page 2024

  8. [8]

    Feng, J., Xu, R., Hao, J., Sharma, H., Shen, Y., Zhao, D., and Chen, W. (2024). Language models can be deductive solvers. In Findings of the Association for Computational Linguistics: NAACL 2024 , pages 4026--4042

    work page 2024

Show all 28 references
  1. [9]

    Gao, L., Madaan, A., Zhou, S., Alon, U., Liu, P., Yang, Y., Callan, J., and Neubig, G. (2022). PAL : Program -aided language models. ArXiv , abs/2211.10435

    2022 arXiv

  2. [10]

    Garcez, A. d. and Lamb, L. C. (2023). Neurosymbolic AI : The 3 rd wave. Artificial Intelligence Review , 56(11):12387--12406. Publisher: Springer

    2023

  3. [11]

    Geibinger, T. (2023). Explainable answer-set programming. arXiv preprint arXiv:2308.15901

    2023 arXiv

  4. [12]

    Hamilton, K., Nayak, A., Božić, B., and Longo, L. (2022). Is neuro-symbolic ai meeting its promises in natural language processing? a structured review. Semantic Web , (Preprint):1--42. Publisher: IOS Press

    2022

  5. [13]

    Ishay, A., Yang, Z., and Lee, J. (2023). Leveraging large language models to generate answer set programs. arXiv preprint arXiv:2307.07699

    2023 arXiv

  6. [14]

    T., Moazam, H., and others (2023)

    Khattab, O., Singhvi, A., Maheshwari, P., Zhang, Z., Santhanam, K., Vardhamanan, S., Haq, S., Sharma, A., Joshi, T. T., Moazam, H., and others (2023). Dspy: Compiling declarative language model calls into self-improving pipelines. arXiv preprint arXiv:2310.03714

    2023 arXiv

  7. [15]

    and Kordjamshidi, P

    Mirzaee, R. and Kordjamshidi, P. (2022). Transfer learning with synthetic corpora for spatial role labeling and reasoning. arXiv preprint arXiv:2210.16952

    2022 arXiv

  8. [16]

    Pan, L., Albalak, A., Wang, X., and Wang, W. Y. (2023). Logic-lm: Empowering large language models with symbolic solvers for faithful logical reasoning. arXiv preprint arXiv:2305.12295

    2023 arXiv

  9. [17]

    Parisi, A., Zhao, Y., and Fiedel, N. (2022). Talm: Tool augmented language models. arXiv preprint arXiv:2205.12255

    2022 arXiv

  10. [18]

    Y., Qian, H., Fagin, R., Barahona, F., Sharma, U., and others (2020)

    Riegel, R., Gray, A., Luus, F., Khan, N., Makondo, N., Akhalwaya, I. Y., Qian, H., Fagin, R., Barahona, F., Sharma, U., and others (2020). Logical neural networks. arXiv preprint arXiv:2006.13155

    2020 arXiv

  11. [19]

    and Schütze, H

    Schick, T. and Schütze, H. (2021). True few-shot learning with prompts—a real-world perspective. Transactions of the Association for Computational Linguistics , 10:716--731

    2021

  12. [20]

    Shi, Z., Zhang, Q., and Lipani, A. (2022). Stepgame: A new benchmark for robust multi-hop spatial reasoning in texts. In Proceedings of the AAAI conference on artificial intelligence , volume 36, pages 11321--11329. Number: 10

    2022

  13. [21]

    Wan, Z., Liu, C.-K., Yang, H., Li, C., You, H., Fu, Y., Wan, C., Krishna, T., Lin, Y., and Raychowdhury, A. (2024). Towards Cognitive AI Systems : a Survey and Prospective on Neuro - Symbolic AI . arXiv:2401.01040 [cs]

    2024 arXiv

  14. [22]

    Wang, J., Liu, Z., Zhao, L., Wu, Z., Ma, C., Yu, S., Dai, H., Yang, Q., Liu, Y.-H., Zhang, S., Shi, E., Pan, Y., Zhang, T., Zhu, D., Li, X., Jiang, X., Ge, B., Yuan, Y., Shen, D., Liu, T., and Zhang, S. (2023). Review of large vision models and visual prompt engineering. ArXiv...

    2023 arXiv

  15. [23]

    Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., and Zhou, D. (2022). Self-consistency improves chain of thought reasoning in language models. ArXiv , abs/2203.11171

    2022 arXiv

  16. [24]

    Weber, L., Minervini, P., Münchmeyer, J., Leser, U., and Rocktäschel, T. (2019). Nlprolog: Reasoning with weak unification for question answering in natural language. arXiv preprint arXiv:1906.06187

    2019 arXiv

  17. [25]

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., Chi, E., Xia, F., Le, Q., and Zhou, D. (2022). Chain of thought prompting elicits reasoning in large language models. ArXiv , abs/2201.11903

    2022 arXiv

  18. [26]

    Yang, Z., Ishay, A., and Lee, J. (2023a). Coupling large language models with logic programming for robust and general reasoning from text. arXiv preprint arXiv:2307.07696

    2023 arXiv

  19. [27]

    Yang, Z., Ishay, A., and Lee, J. (2023b). Neurasp: Embracing neural networks into answer set programming. arXiv preprint arXiv:2307.07700

    2023 arXiv

  20. [28]

    Zhou, D., Scharli, N., Hou, L., Wei, J., Scales, N., Wang, X., Schuurmans, D., Bousquet, O., Le, Q., and Chi, E. (2022). Least-to-most prompting enables complex reasoning in large language models. ArXiv , abs/2205.10625

    2022 arXiv

Pith tools

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