Rationalization Models for Text-to-SQL

Dharmashankar Subramanian; Gaetano Rossiello; Junkyu Lee; Michael Glass; Nhan Pham

REVIEW 3 major objections 6 minor 31 references

Rationalization Models for Text-to-SQL

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

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

Pith's one-line read Fine-tuning a small text-to-SQL model on validated, step-by-step SQL-building rationales improves execution accuracy on the BIRD benchmark, with the longest rationale variant gaining 4.86 points on the most challenging queries.

desk verdict A competent pipeline for execution-validated CoT rationales in text-to-SQL, with a small but plausible BIRD gain; the interpretability claim is softer than the accuracy claim because only final SQL is validated. read the letter →

arxiv 2502.06759 v4 pith:6USXZ6DV submitted 2025-02-10 cs.CL cs.AIcs.DB

Gaetano Rossiello , Nhan Pham , Michael Glass , Junkyu Lee , Dharmashankar Subramanian This is my paper · ORCID

classification cs.CLcs.AIcs.DB

keywords text-to-SQLchain-of-thoughtrationalizationknowledgedistillationdynamicfew-shotBIRDbenchmarkexecutionaccuracySQLgeneration

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 fine-tuning a small text-to-SQL model on step-by-step 'SQL-building rationales'—chains of increasingly complex executable SQL statements with explanations—makes the model more accurate on hard queries and more transparent in its reasoning. The authors build a pipeline that starts from two manually annotated examples, uses a 70B teacher model with dynamic few-shot selection to propose rationales for the BIRD training set, keeps only those whose final SQL executes to the exact result set of the gold SQL, and then trains an 8B rationalization model to cover the remaining training pairs. On the BIRD dev set, an 8B Llama model fine-tuned on the longest validated rationales reaches 67.41% execution accuracy, versus 66.17% for the same model trained on gold SQL alone, with a 4.86-point gain on the most challenging queries. The paper takes this as evidence that long, validated reasoning chains transfer to small models and can be produced at scale with minimal manual annotation.

What carries the argument

The load-bearing mechanism is the validated-SQL-CoT loop: a teacher LLM receives a schema-filtered prompt, the question, the gold SQL, and the top-n most similar validated rationales, and produces a Markdown-formatted plan followed by intermediate executable SQL statements; a DBMS validates the trace by requiring exact result-set equality between the final SQL and the gold SQL. Validated traces accumulate in a repository and are used as few-shot examples in the next iteration, selected by cosine similarity over SQL-keyword vectors. A rationalization model, fine-tuned on these traces with (question, gold SQL) as input, then generates rationalizations for every remaining training pair. The comparison between short and long validated rationales is what isolates length of reasoning as the factor that raises execution accuracy on hard queries.

What would settle it

Take the same 8,807 training pairs and the same longest validated rationales, replace each intermediate SQL statement with a different executable statement that still leads to the same final result set, and fine-tune the same Llama 3.1 8B model; if BIRD dev accuracy does not drop, the reported gain comes from output format and length rather than from the correctness of the intermediate reasoning.

Watch

Extended reading notes

Core claim

The central discovery is that for text-to-SQL, the target used in fine-tuning can be upgraded from the final SQL answer to a validated, step-by-step construction of that answer, and that among the validated constructions the longer ones are the better training signal. A rationale is considered valid only if the final SQL it contains, when executed against the database, returns exactly the same result set as the gold SQL. The generation loop iterates dynamic few-shot prompting with a 70B teacher, where the few-shot examples are the most structurally similar previously validated rationales, ranked by cosine similarity of SQL-keyword frequency vectors. Once coverage stops growing, an 8B rationalization model is fine-tuned on the validated rationales and applied to all remaining training pairs, with the gold SQL given as input, so that the training set is fully covered by rationalizations. The controlled comparison on BIRD shows that the longest-Co-trained model outperforms the gold-only baseline across all difficulty levels and gains the most on challenging queries, while also emitting human-readable explanations of each SQL-building step.

Load-bearing premise

The pipeline assumes that when a generated chain-of-thought's final SQL executes to the exact result set of the gold SQL, the intermediate steps are correct enough to serve as a training target.

Editorial extensions

If this is right

If the claim holds, small text-to-SQL models can be improved by changing only the training target—from SQL answers to validated step-by-step rationales—without changing architecture or scaling.
The rationalization model, once trained, can annotate new text-to-SQL datasets across different domains without repeating the manual-annotation and dynamic-few-shot loop, as the paper explicitly proposes.
Longer validated rationales become a practical knob: fine-tuning on the longest traces gives the best accuracy on simple, moderate, and challenging queries alike, while preserving interpretability.
The validation step doubles as a data-cleaning tool, since rationalization failures often expose inconsistencies or errors in the gold SQL itself.

Reading between the lines

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

A stricter test of the paper's interpretation would separate format from reasoning: if the same long traces with their intermediate steps shuffled still produce the same dev accuracy, the gain is a property of output length and structure, not of the validity of the reasoning.
The SQL-keyword cosine-similarity selector is a deliberately simple retrieval; replacing it with semantic or learned similarity could change the coverage curve, so the reported gains are partly a statement about this particular few-shot selection.
The method should transfer to other tasks with executable intermediate artifacts—for example, data-analysis code or spreadsheet formulas—where result-set equivalence is cheap to check and the final output can validate the trace.
Because the validation criterion certifies only the final result, the generated rationales are optimized for execution accuracy rather than for psychological plausibility; user-facing explanations may therefore be correct in outcome but not in the stated rationale.

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.

Desk Editor's Note

read the letter

The paper does one real thing: it shows that fine-tuning an 8B text-to-SQL model on execution-validated chain-of-thought rationales can nudge BIRD dev accuracy from 66.17 to 67.41, with the gain concentrated on hard queries. The pipeline is a clean combination of known pieces—dynamic few-shot with SQL-keyword retrieval, STaR-style rationalization, execution checking—and it is honest enough to report that the gain only appears after full coverage and with the longest CoT variant.

What is new: the SQL-keyword similarity retrieval for few-shot selection and the iterative coverage-growth distillation. These work in the narrow sense that validation coverage goes from 53% with two manual seeds to 74% after dynamic few-shot, then to 99% with the rationalization model. That is a concrete, reproducible-sounding number.

The main soft spot is the validation criterion. Matching the final result set guarantees the final SQL is correct, but says nothing about intermediate steps. Since the paper's secondary claim is interpretability, that is a real gap. The manual check of only 86 instances is too small to license the claim. Second, the comparison is single-run and the Long-vs-Short choice is made after looking at the dev set. At 74% coverage the CoT models are actually worse overall, so the positive result is conditional on the rationalization stage and on dev-set selection. That makes the headline 'long CoTs enhance accuracy' too strong. Third, the gain is about one point; with no error bars, it could be noise, though it is consistent across the three difficulty strata.

To its credit, the paper reports the negative intermediate result and does not hide the six training-set comparison. The appendix example makes the rationale format concrete.

Who is this for? People working on small-model text-to-SQL or rationale distillation. It is not a breakthrough; it is a decent data-generation recipe with a plausible-but-thin evaluation. I would send it to a serious referee. It deserves revision rather than rejection: multi-seed runs, held-out selection, and a systematic audit of intermediate steps would materially improve it. The accuracy claim is worth engaging; the interpretability claim needs more evidence.

Referee Report

3 major / 6 minor

Summary. The paper proposes a framework for generating chain-of-thought (CoT) rationales for text-to-SQL by combining a small set of manually annotated seeds, a dynamic few-shot distillation procedure from a 70B teacher model, execution-based validation of the final SQL, and a fine-tuned rationalization model that reaches full training coverage. The authors fine-tune Llama 3.1 8B on the BIRD dataset with and without these rationales and report that the longest CoT variant at full coverage improves execution accuracy over a gold-SQL baseline, especially on challenging queries (67.41 vs. 66.17 overall; +4.86 on the challenging subset).

Significance. If the result holds, the framework would offer a practical way to produce step-by-step SQL-building rationales at scale for training smaller text-to-SQL models, improving accuracy on complex queries and providing interpretable outputs. The paper is transparent about coverage numbers and reports the full pattern of results at both coverage levels, which is a strength. However, the current evidence is not yet fully convincing because the evaluation relies on single runs without error bars, the best-performing variant is chosen after inspecting dev-set results, and the validation of rationales checks only the final SQL, not the soundness of intermediate steps.

major comments (3)

[Section 3.2, Table 2] The central comparison rests on a single fine-tuning run per condition, with no error bars, confidence intervals, or significance tests. The reported overall improvement is +1.24 percentage points (67.41 vs. 66.17) on the dev set, and the +4.86 improvement on challenging queries is on an unreported subset size. Because the short and long variants are evaluated on the same dev set and the best-performing variant is highlighted, the headline result may reflect selection over multiple configurations. Multiple seeds or a pre-registered selection rule are needed to support the claim that long CoTs enhance accuracy.
[Section 2.2, Section 3.1] The validation component labels a generated CoT as positive only when the final SQL in the trace executes to the same result set as the gold SQL. This does not verify the correctness of the intermediate SQL statements or the textual explanations. The manual assessment described in Section 3.1 covers only the 86 instances remaining after the rationalization stage, not the thousands of validated CoTs used for training. Consequently, the interpretability claim is unverified, and the observed accuracy gain could come from the final SQL embedded in the trace rather than from sound intermediate reasoning. A systematic audit of intermediate steps, or an ablation in which intermediate steps are corrupted to measure their effect, would be needed to support the interpretation.
[Conclusion vs. Table 2] The conclusion states that 'long CoTs enhance the accuracy of text-to-SQL tasks,' but Table 2 shows this only in the full-coverage (99.02%) Long CoT condition. At 73.86% coverage, both CoT variants are below the gold-SQL baseline overall (63.82 and 61.99 vs. 63.95), although they improve on moderate and challenging queries. As written, the claim overgeneralizes; it should be restricted to the full-coverage, Long-variant setting, or the paper should analyze the conditions under which rationales help.

minor comments (6)

[Section 3.1, Section 3.2] The cross-references to 'Table 3.1' and 'Table 3.2' in the text should be corrected to 'Table 1' and 'Table 2'.
[Section 3.2] The text says 'Using 73.68% of the training set,' but Table 2 reports 73.86% coverage for the dynamic few-shot stage; please reconcile.
[Table 2] Decimal places are inconsistent (e.g., '70.7' vs. '70.70', '46.9' vs. '46.90'), and the column header 'Challenge' is used alongside 'challenging' in the text; please unify terminology.
[Section 3.2] The phrase 'an increase of +4.86%' should be stated as '+4.86 percentage points' to avoid ambiguity.
[Section 2.2] The statement that two result sets 'match exactly' should specify whether row order and duplicate rows are considered, since this affects the interpretation of SQL equivalence.
[Section 3] The paper does not report fine-tuning hyperparameters (learning rate, epochs, batch size, sequence length), which would be needed for reproduction.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the BIRD dev accuracy comparison is an independent empirical evaluation; the only self-citation (schema linker) is a pipeline component, not the target result.

full rationale

The paper's central claim is an empirical comparison: fine-tuning a small text-to-SQL model on validated SQL-building rationales (long CoT variant) improves execution accuracy on the BIRD dev set. This claim is not circular. The dev set is explicitly retained as an independent test set ('The original dev set, consisting of 1,534 instances, is retained', Section 3) and is never used for rationale generation, validation, or selection. The validation criterion ('If the two result sets match exactly, the CoT is labeled as a positive example', Section 2.2) defines which training rationales are used, but it does not determine the dev-set accuracy; the accuracy comparison is a standard supervised evaluation with an external benchmark. The only self-referential element is the schema linker cited as 'Glass et al., 2025' (Section 2.2), a component used to filter database schemas in prompts. Although the author lists overlap, this citation is not used as a uniqueness theorem or as a proof of the paper's conclusion; it is a pipeline tool, and the paper does not derive its accuracy numbers from the linker. The post-hoc selection of the longest CoT among several training-set variants is a model-selection issue, not a definitional reduction. A separate concern is that execution-match validation does not audit intermediate reasoning steps, so the 'interpretable, user-friendly output' claim is not fully supported; however, this is a validity/quality limitation, not a circular derivation. Under the stated rules, no circular step can be exhibited.

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

The paper postulates no new physical or formal entities. Its empirical claims rest on validation-by-execution, the correctness of the cleaned BIRD gold SQLs, the schema linker component, and the ability of the 8B student to imitate the 70B teacher's rationalizations. The main free choices are the selection of the Long CoT variant on the dev set and the undocumented cleaning thresholds.

free parameters (3)

Long-vs-Short CoT selection = Long (chosen post hoc from dev results)
The paper compares Short and Long CoT variants and then reports Long as the better method based on the same BIRD dev set, a post-hoc model selection without a held-out set.
Number of dynamic few-shot iterations = 13
Coverage stops increasing after 13 iterations; the stopping rule and the alternating greedy/sampling schedule are heuristics chosen without a validation set.
Training-data cleaning threshold = unspecified timeout
The paper removes gold SQLs that timeout or return empty results, but does not specify the timeout value or the exact filter, making the effective training set (8,807 pairs) not exactly reproducible.

assumptions (4)

domain assumption Exact execution result matching between final CoT SQL and gold SQL is a sufficient validation signal for rationale correctness.
Used throughout Sections 2.2 and 2.3 to label generated CoTs as positive or negative; semantically equivalent SQL may produce different result sets due to ordering or duplicates, and correct reasoning can have an execution mismatch.
domain assumption BIRD train and dev split is free of leakage and gold SQLs are clean after removing non-executable instances.
Assumed to ensure the dev-set evaluation measures generalization; the paper itself finds gold SQL errors in 0.98% of the remaining training instances.
domain assumption The schema linker (Glass et al., 2025) correctly filters schemas for both teacher and student inference.
All prompts include schema filtered by the linker; errors in this component would propagate to all generated rationales.
domain assumption A fine-tuned 8B model can faithfully reproduce validated rationalizations of a 70B teacher at scale.
Section 2.3 relies on the student rationalization model to generate valid CoTs on roughly 26% of training instances.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Rationalization Models for Text-to-SQL." pith.science (2026). https://pith.science/paper/6USXZ6DV

@misc{pith2026250206759,
  author       = {Pith},
  title        = {Pith review of: Rationalization Models for Text-to-SQL},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6USXZ6DV}},
  note         = {Machine review of arXiv:2502.06759}
}

read the original abstract

We introduce a framework for generating Chain-of-Thought (CoT) rationales to enhance text-to-SQL model fine-tuning. These rationales consist of intermediate SQL statements and explanations, serving as incremental steps toward constructing the final SQL query. The process begins with manually annotating a small set of examples, which are then used to prompt a large language model in an iterative, dynamic few-shot knowledge distillation procedure from a teacher model. A rationalization model is subsequently trained on the validated decomposed queries, enabling extensive synthetic CoT annotations for text-to-SQL datasets. To evaluate the approach, we fine-tune small language models with and without these rationales on the BIRD dataset. Results indicate that step-by-step query generation improves execution accuracy, especially for moderately and highly complex queries, while also enhancing explainability.

Figures

Figures reproduced from arXiv: 2502.06759 by the authors.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 14 canonical work pages

[1]

Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. Trans. Mach. Learn. Res., 2023, 2023

work page 2023
[2]

Copestake and Karen Sparck Jones

Ann A. Copestake and Karen Sparck Jones. Natural language interfaces to databases. Knowl. Eng. Rev., 5 0 (4): 0 225--249, 1990

work page 1990
[3]

DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai D...

2025
[4]

C3: zero-shot text-to-sql with chatgpt

Xuemei Dong, Chao Zhang, Yuhang Ge, Yuren Mao, Yunjun Gao, Lu Chen, Jinshu Lin, and Dongfang Lou. C3: zero-shot text-to-sql with chatgpt. CoRR, abs/2307.07306, 2023

arXiv 2023
[5]

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al - Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, Anirudh Goyal, Anthony Hartshorn, Aobo Yang, Archi Mitra, Archie Sravankumar, Artem Korenev, Arthur Hinsvark, Arun Rao, Aston Zhang, Aur \' e lien Rodriguez, Austen Gregerson, Ava Spataru, Baptiste Rozi \` e...

arXiv 2024
[6]

Complexity-based prompting for multi-step reasoning

Yao Fu, Hao Peng, Ashish Sabharwal, Peter Clark, and Tushar Khot. Complexity-based prompting for multi-step reasoning. In ICLR . OpenReview.net, 2023

work page 2023
[7]

Text-to-sql empowered by large language models: A benchmark evaluation

Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. Text-to-sql empowered by large language models: A benchmark evaluation. Proc. VLDB Endow. , 17 0 (5): 0 1132--1145, 2024 a

work page 2024
[8]

Xiyan-sql: A multi-generator ensemble framework for text-to-sql

Yingqi Gao, Yifu Liu, Xiaoxia Li, Xiaorong Shi, Yin Zhu, Yiming Wang, Shiqi Li, Wei Li, Yuntao Hong, Zhiling Luo, Jinyang Gao, Liyu Mou, and Yu Li. Xiyan-sql: A multi-generator ensemble framework for text-to-sql. CoRR, abs/2411.08599, 2024 b

arXiv 2024

Show all 31 references

[9]

Glass, Mustafa Eyceoz, Dharmashankar Subramanian, Gaetano Rossiello, Long Vu, and Alfio Gliozzo

Michael R. Glass, Mustafa Eyceoz, Dharmashankar Subramanian, Gaetano Rossiello, Long Vu, and Alfio Gliozzo. Extractive schema linking for text-to-sql. CoRR, abs/2501.17174, 2025

2025 arXiv
[10]

Hendrix, Earl D

Gary G. Hendrix, Earl D. Sacerdoti, Daniel Sagalowicz, and Jonathan Slocum. Developing a natural language interface to complex data. ACM Trans. Database Syst. , 3 0 (2): 0 105--147, 1978

1978
[11]

Large language models can self-improve

Jiaxin Huang, Shixiang Gu, Le Hou, Yuexin Wu, Xuezhi Wang, Hongkun Yu, and Jiawei Han. Large language models can self-improve. In EMNLP , pp.\ 1051--1068. Association for Computational Linguistics, 2023

2023
[12]

Large language models are zero-shot reasoners

Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large language models are zero-shot reasoners. In NeurIPS, 2022

2022
[13]

Wang, and Tao Yu

Fangyu Lei, Jixuan Chen, Yuxiao Ye, Ruisheng Cao, Dongchan Shin, Hongjin Su, Zhaoqing Suo, Hongcheng Gao, Wenjing Hu, Pengcheng Yin, Victor Zhong, Caiming Xiong, Ruoxi Sun, Qian Liu, Sida I. Wang, and Tao Yu. Spider 2.0: Evaluating language models on real-world enterprise text...

2024 arXiv
[14]

Can LLM already serve as A database interface? A big bench for large-scale database grounded text-to-sqls

Jinyang Li, Binyuan Hui, Ge Qu, Jiaxi Yang, Binhua Li, Bowen Li, Bailin Wang, Bowen Qin, Ruiying Geng, Nan Huo, Xuanhe Zhou, Chenhao Ma, Guoliang Li, Kevin Chen - Chuan Chang, Fei Huang, Reynold Cheng, and Yongbin Li. Can LLM already serve as A database interface? A big bench ...

2023
[15]

Teaching small language models to reason for knowledge-intensive multi-hop question answering

Xiang Li, Shizhu He, Fangyu Lei, JunYang JunYang, Tianhuang Su, Kang Liu, and Jun Zhao. Teaching small language models to reason for knowledge-intensive multi-hop question answering. In ACL (Findings) , pp.\ 7804--7816. Association for Computational Linguistics, 2024

2024
[16]

Let's verify step by step

Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step. In ICLR . OpenReview.net, 2024

2024
[17]

Dynamic prompt learning via policy gradient for semi-structured mathematical reasoning

Pan Lu, Liang Qiu, Kai - Wei Chang, Ying Nian Wu, Song - Chun Zhu, Tanmay Rajpurohit, Peter Clark, and Ashwin Kalyan. Dynamic prompt learning via policy gradient for semi-structured mathematical reasoning. In ICLR . OpenReview.net, 2023

2023
[18]

The death of schema linking? text-to-sql in the age of well-reasoned language models

Karime Maamari, Fadhil Abubaker, Daniel Jaroslawicz, and Amine Mhedhbi. The death of schema linking? text-to-sql in the age of well-reasoned language models. CoRR, abs/2408.07702, 2024

2024 arXiv
[19]

Teaching small language models to reason

Lucie Charlotte Magister, Jonathan Mallinson, Jakub Ad \' a mek, Eric Malmi, and Aliaksei Severyn. Teaching small language models to reason. In ACL (2) , pp.\ 1773--1781. Association for Computational Linguistics, 2023

2023
[20]

Evaluating cross-domain text-to-sql models and benchmarks

Mohammadreza Pourreza and Davood Rafiei. Evaluating cross-domain text-to-sql models and benchmarks. In EMNLP , pp.\ 1601--1611. Association for Computational Linguistics, 2023

2023
[21]

Mohammadreza Pourreza, Hailong Li, Ruoxi Sun, Yeounoh Chung, Shayan Talaei, Gaurav Tarlok Kakkar, Yu Gan, Amin Saberi, Fatma Ozcan, and Sercan \" O . Arik. CHASE-SQL: multi-path reasoning and preference optimized candidate selection in text-to-sql. CoRR, abs/2410.01943, 2024

arXiv
[22]

Automatic prompt augmentation and selection with chain-of-thought from labeled data

Kashun Shum, Shizhe Diao, and Tong Zhang. Automatic prompt augmentation and selection with chain-of-thought from labeled data. In EMNLP (Findings) , pp.\ 12113--12139. Association for Computational Linguistics, 2023

2023
[23]

CHESS: contextual harnessing for efficient SQL synthesis

Shayan Talaei, Mohammadreza Pourreza, Yu - Chen Chang, Azalia Mirhoseini, and Amin Saberi. CHESS: contextual harnessing for efficient SQL synthesis. CoRR, abs/2405.16755, 2024

2024 arXiv
[24]

MAC-SQL: A multi-agent collaborative framework for text-to-sql

Bing Wang, Changyu Ren, Jian Yang, Xinnian Liang, Jiaqi Bai, Linzheng Chai, Zhao Yan, Qian - Wen Zhang, Di Yin, Xing Sun, and Zhoujun Li. MAC-SQL: A multi-agent collaborative framework for text-to-sql. In COLING , pp.\ 540--557. Association for Computational Linguistics, 2025

2025
[25]

Chi, Quoc V

Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models. In NeurIPS, 2022

2022
[26]

Explanation selection using unlabeled data for in-context learning

Xi Ye and Greg Durrett. Explanation selection using unlabeled data for in-context learning. CoRR, abs/2302.04813, 2023

2023 arXiv
[27]

Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman. Star: Bootstrapping reasoning with reasoning. In NeurIPS, 2022

2022
[28]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...
[29]

@esa (Ref

\@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should ...
[30]

\@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@firs...
[31]

distillation

@open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibset...

2022

Pith tools

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

[1] [1]

Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. Trans. Mach. Learn. Res., 2023, 2023

work page 2023

[2] [2]

Copestake and Karen Sparck Jones

Ann A. Copestake and Karen Sparck Jones. Natural language interfaces to databases. Knowl. Eng. Rev., 5 0 (4): 0 225--249, 1990

work page 1990

[3] [3]

DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai D...

2025

[4] [4]

C3: zero-shot text-to-sql with chatgpt

Xuemei Dong, Chao Zhang, Yuhang Ge, Yuren Mao, Yunjun Gao, Lu Chen, Jinshu Lin, and Dongfang Lou. C3: zero-shot text-to-sql with chatgpt. CoRR, abs/2307.07306, 2023

arXiv 2023

[5] [5]

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al - Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, Anirudh Goyal, Anthony Hartshorn, Aobo Yang, Archi Mitra, Archie Sravankumar, Artem Korenev, Arthur Hinsvark, Arun Rao, Aston Zhang, Aur \' e lien Rodriguez, Austen Gregerson, Ava Spataru, Baptiste Rozi \` e...

arXiv 2024

[6] [6]

Complexity-based prompting for multi-step reasoning

Yao Fu, Hao Peng, Ashish Sabharwal, Peter Clark, and Tushar Khot. Complexity-based prompting for multi-step reasoning. In ICLR . OpenReview.net, 2023

work page 2023

[7] [7]

Text-to-sql empowered by large language models: A benchmark evaluation

Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. Text-to-sql empowered by large language models: A benchmark evaluation. Proc. VLDB Endow. , 17 0 (5): 0 1132--1145, 2024 a

work page 2024

[8] [8]

Xiyan-sql: A multi-generator ensemble framework for text-to-sql

Yingqi Gao, Yifu Liu, Xiaoxia Li, Xiaorong Shi, Yin Zhu, Yiming Wang, Shiqi Li, Wei Li, Yuntao Hong, Zhiling Luo, Jinyang Gao, Liyu Mou, and Yu Li. Xiyan-sql: A multi-generator ensemble framework for text-to-sql. CoRR, abs/2411.08599, 2024 b

arXiv 2024