Pith. sign in

REVIEW 4 major objections 6 minor 39 references

SCOPE: Compress Mathematical Reasoning Steps for Efficient Automated Process Annotation

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

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

Pith's one-line read A prefix tree of code steps cuts PRM annotation cost to 5 percent, and improves downstream accuracy.

desk verdict A useful sample-and-compress method for cheap PRM labels, with a real but addressable hole: no decontamination analysis between its UltraInteract training data and the eval benchmarks. read the letter →

arxiv 2505.14419 v1 pith:E3G6SXQM submitted 2025-05-20 cs.AI

Huimin Xu , Xin Mao , Feng-Lin Li , Xiaobao Wu , Wang Chen , Wei Zhang , Anh Tuan Luu This is my paper
classification cs.AI
keywords processrewardmodelsmathematicalreasoningdataannotationprefixtreeabstractsyntaxcodetranslationcomputationalefficiencyBest-of-N
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

Process reward models that score each reasoning step need step-level labels, and existing automatic labeling schemes buy them with heavy simulation compute: they sample many extra completions just to estimate whether a step leads to a correct answer. This paper argues that the simulation step is unnecessary. It proposes translating each natural-language reasoning step into Python code, normalizing that code through an Abstract Syntax Tree so that algebraically identical steps collapse to the same representation, and merging all normalized steps from many sampled solutions into a prefix tree. In that tree, each node's Q-value is simply the fraction of correct solutions passing through it, and every root-to-leaf path becomes a ready-made training sample. The paper reports building a 196K-sample, 1.4M-label dataset at about 5% of the GPU cost of Math-Shepherd, with PRMs trained on that data outperforming existing automated annotation methods on both Best-of-N selection and ProcessBench.

What carries the argument

The prefix tree (Trie) built from AST-normalized code blocks. Each reasoning step is first translated into Python code by a code LLM, then normalized via Abstract Syntax Tree transformations: variable and function renaming to canonical forms, mapping of synonyms to canonical operators, reordering of commutative operands, and constant folding. Normalized steps with identical code are merged into a Trie, where each path is a sampled solution; Q-values are computed recursively from leaf correctness weighted by solution counts, and each root-to-leaf path becomes a training sample with hard or soft step labels.

What would settle it

Take a sample of hard problems (for instance from OlympiadBench) and have two human annotators label each pair of reasoning steps as mathematically equivalent or not; then run SCOPE's translation, normalization, and merging on the same steps. If many human-equivalent pairs produce different normalized code, or many human-distinct pairs merge, the compression fails exactly where the method most needs to work.

Watch

Extended reading notes

Core claim

The central claim is that Monte Carlo simulation—the standard way to auto-label process steps—can be replaced by a compression operation on the already-sampled solutions. Code translation plus AST normalization identifies mathematically equivalent steps accurately enough that a prefix tree of merged solutions preserves the information that simulations would have gathered, and does so in O(N) time instead of O(NMK). The resulting dataset yields PRMs that beat other automated annotation approaches on Best-of-8 accuracy and approach the performance of a PRM trained on the human-annotated PRM800K corpus on ProcessBench.

Load-bearing premise

The load-bearing premise is that a 32B code model translates natural-language math steps into Python code accurately enough that equivalent steps collapse to identical normalized code and non-equivalent steps do not. The paper's own limitations section concedes that complex mathematical concepts can defeat translation fidelity, which would corrupt the prefix tree and its labels.

Editorial extensions

If this is right

  • Automated PRM annotation becomes linear in the number of sampled solutions, so the cost of building step-level supervision no longer grows with a simulation budget.
  • PRMs trained on compressed data can outperform majority voting on Best-of-8 selection, suggesting process supervision captures information that simple aggregation misses.
  • The method reaches close to the ProcessBench performance of a PRM trained on human annotations, indicating automated labels can approach manual quality on this benchmark.
  • Ablations show that both code translation and AST normalization matter: removing either lowers compression quality and downstream accuracy, and over-merging comment-only steps also hurts performance.
  • Because hard labels outperform soft Q-value labels in the experiments, the authors conclude that raw Q-values carry noise that binarization filters.

Reading between the lines

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

  • If the equivalence-finding pipeline is as general as the paper suggests, the same sample-and-compress strategy could apply to other step-wise reasoning domains with executable semantics, such as code repair or theorem-proving traces, where steps can be compiled to canonical forms.
  • The reliance on a 32B code LLM for translation is a bottleneck the paper only partially acknowledges: a natural test is whether a weaker or cheaper translator degrades downstream PRM performance in proportion to its translation error rate.
  • The hard-label win over soft labels hints that Q-values computed on a 64-sample prefix tree are noisy estimates of step correctness; a variance-reduced Q-value estimator might recover the soft-label advantage on harder problems.
  • A concrete prediction following from the compression argument is that SCOPE's advantage over simulation-based labeling should shrink on problems where step equivalence is semantically rich but syntactically varied, because code normalization captures less of the underlying math.
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 / 6 minor

Summary. The paper proposes SCOPE, an automatic process-annotation pipeline that replaces Monte Carlo simulation with compression. Natural-language reasoning steps from sampled solutions are translated into Python code, normalized via Abstract Syntax Tree transformations, and merged into a prefix tree whose nodes carry Q-values (the proportion of solution paths through that node that reach the correct answer). This yields a training dataset of 196K samples and 1.4M step labels at about 5% of the computational cost claimed for MathShepherd. The authors report that PRMs trained on SCOPE outperform existing automated annotation baselines on Best-of-8 over six math benchmarks and on ProcessBench average F1, with ablations isolating the contributions of code translation and AST normalization.

Significance. If the empirical claims are reliable, SCOPE is a genuinely useful contribution: it offers a simple, fully automatic route to large-scale process supervision, and the paper ships code, data, and models, which aids reproducibility. The two main ablations are sensible and show that both code translation and AST normalization contribute to downstream performance, and the evaluation on ProcessBench goes beyond Best-of-N accuracy. The limitations section is honest about translation fidelity and mathematical coverage. However, the central comparative claims currently rest on single-run numbers, on an unverified assumption of no train/evaluation overlap, and on a stated loss function that is mathematically wrong. These issues are fixable, and the core idea is not invalidated by the ablation evidence, so the paper warrants a major revision rather than rejection.

major comments (4)
  1. [Section 3.4, Eq. (4)] The soft-label loss is written as L_SE = -\sum_{i=1}^K (y_{s_i} - \hat{y}_{s_i})^2. Minimizing this objective maximizes squared error, which is the opposite of the stated 'mean squared error (MSE) loss.' Unless the implementation actually used a positive MSE, the soft-label results in Table 3 and the discussion in Section 4.6 are not valid. Please correct the sign and rerun the soft-label experiments.
  2. [Section 4.1, Dataset Construction and Evaluation] The manuscript reports no decontamination check between the UltraInteract training subset and the evaluation benchmarks (GSM8K, MATH, MinervaMath, GaoKao2023En, OlympiadBench, CollegeMath, and the ProcessBench subsets). UltraInteract is a large general-purpose math instruction corpus, and the evaluation benchmarks are standard public sets, so exact or near-duplicate overlap is plausible. If overlap exists, the Best-of-8 gains in Table 1 and the ProcessBench F1 in Table 2 could reflect memorization of correct solutions rather than the benefit of step compression. Please add an overlap analysis (exact match, normalized n-gram overlap, and near-duplicate detection) and re-run the comparison on a clean non-overlapping subset.
  3. [Section 4.1, Dataset Construction] The filter that retains only problems with model confidence greater than 0.75 (i.e., at least 48 of 64 sampled solutions correct) makes the training distribution deliberately easy and removes all hard problems. The paper does not report how many UltraInteract problems survive this filter, the distribution of confidence scores, or an ablation over thresholds. This matters for the claim that SCOPE produces a generally useful PRM training set, and it also interacts with potential contamination, because easy benchmark problems are more likely to be solved and retained. Please report these statistics and a threshold sweep.
  4. [Sections 1, 3.3, and Appendix B] The complexity claim 'from O(NMK) to O(N)' omits K. Code translation is one model call per solution, but each call produces O(K) code blocks, and AST normalization and trie construction process all K steps of each of N solutions, giving O(NK) step-level work rather than O(N). If K is treated as a bounded constant the claim is harmless, but as written the abstract and Section 1 overstate the improvement. Please state the complexity as O(NK) (or state the bounded-K assumption) consistently in the abstract, Section 1, Section 3.3, and Table 4.
minor comments (6)
  1. [Tables 1-3] The main tables report single-run results without error bars or significance tests; in particular, SCOPE's 1.0-point margin over Skywork-PRM-7B in Table 1 may be within run-to-run variance. Please add multiple seeds or a significance statement.
  2. [Sections 4.3 and 4.4, Figure 4] The term 'compression rate' is defined as compressed nodes divided by raw steps, so a higher value means less compression; the text then says a higher compression rate indicates less effective compression, which is counterintuitive. Please rename the quantity (e.g., 'redundancy rate') or invert the definition, and clarify the sentence in Section 4.4 that says both strategies 'decrease the compression ratio' immediately before saying this decrease 'comes at a cost.'
  3. [Appendix B.2 and Figure 5] Figure 5 compares GPU hours on a 100-problem sample, while Table 4 reports stage-level GPU hours that appear to refer to the full dataset. Please state explicitly which basis the '5% of computational resources' claim refers to, and align the notation.
  4. [Section 4.1, Dataset Construction] The text says 'generate 64 solutions per problem' and then reports 'the final dataset contains 196K samples,' which is ambiguous: are these 196K problems, solutions, or root-to-leaf paths from the prefix tree? Please define the unit of 'samples'.
  5. [Sections 3.1-3.2 and Limitations] Translation fidelity and equivalence-merge accuracy are not directly measured. The downstream ablations are reassuring, but reporting a small human audit of code translations and of merge false-positive/negative rates would make the central compression claim more tangible.
  6. [Table 2] The column header 'CorrectF1' runs together with 'Error'; please fix the formatting.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SCOPE's automated labels are computed from sampled-solution outcomes and evaluated on external benchmarks, so the central claim does not reduce to its inputs.

full rationale

SCOPE's derivation chain is: sample 64 solutions per UltraInteract problem, translate steps to code, AST-normalize, merge into a prefix tree, compute Q-values as the proportion of passing solutions that reach the correct final answer, and train a PRM to predict those labels. The evaluation (Best-of-8 on GSM8K/MATH/MinervaMath/GaoKao2023En/OlympiadBench/CollegeMath, and ProcessBench) uses held-out benchmarks and compares against fixed baseline PRMs. No parameter is fitted to the evaluation targets; no label is defined in terms of the benchmark outcomes. The 'prediction' is the PRM's generalization to unseen problems, which is not equivalent by construction to the training Q-values. Self-citations (Wu 2025; Wu et al. 2020, 2024a-c; Pan et al. 2024) appear only in related-work and future-work contexts and are not load-bearing for the central result. The absence of an explicit decontamination check for overlap between UltraInteract and the evaluation benchmarks is a legitimate correctness risk, but it is an empirical data-contamination concern, not a circularity in the derivation. The paper's own limitation about code-translation reliability is likewise a fidelity/robustness issue, and the w/o-code-translation ablation (64.0 BoN, 50.6 ProcessBench) shows the main comparison does not rest entirely on that translation step. Therefore no circular step can be exhibited with the required quote-and-reduction standard.

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

The central claim rests on the fidelity of code translation and AST-based equivalence matching, plus the standard PRM assumption that Q-value proportions are useful process labels. The only hand-chosen numbers are generation hyperparameters and a dataset filtering threshold. No new physical or conceptual entities are introduced.

free parameters (4)
  • number of sampled solutions per problem N = 64
    Hand-chosen. Q-values are proportions over these 64 solutions; larger N would reduce variance but increase compute.
  • model confidence threshold = 0.75
    Problems whose sampled correct-rate exceeds 0.75 are kept; excluding harder problems may bias the training set toward easy examples (Section 4.1).
  • solution generation temperature and top-p = 0.8
    Generation hyperparameters that affect solution diversity and Q-value estimate quality (Section 4.1).
  • code translation temperature = 0
    Chosen for deterministic code output; affects translation quality and downstream compression (Section 4.1).
assumptions (4)
  • domain assumption Qwen2.5-Coder-32B-Instruct translates each natural-language reasoning step into executable Python code with sufficient fidelity.
    Section 3.1; the entire equivalence detection rests on this translation. Paper's Limitations admit it 'heavily depends' on the code LLM's ability.
  • domain assumption After AST normalization, identical normalized code implies mathematical equivalence of steps.
    Section 3.2; variable renaming, operation normalization, expression reordering, and constant folding assume code captures math semantics. Coverage limits for abstract algebra and calculus are acknowledged.
  • domain assumption The Q-value of a node, defined as the proportion of sampled solutions passing through it that reach the correct answer, is a valid training label for a process reward model.
    Sections 3.3 and 3.4; this is the same assumption used by Monte Carlo PRM methods such as Math-Shepherd, carried over implicitly.
  • domain assumption Final-answer correctness can be determined automatically for all generated solutions.
    Implicit in the Q-value computation; used for all benchmarks but not stated or verified explicitly.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SCOPE: Compress Mathematical Reasoning Steps for Efficient Automated Process Annotation." pith.science (2026). https://pith.science/paper/E3G6SXQM

@misc{pith2026250514419,
  author       = {Pith},
  title        = {Pith review of: SCOPE: Compress Mathematical Reasoning Steps for Efficient Automated Process Annotation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/E3G6SXQM}},
  note         = {Machine review of arXiv:2505.14419}
}
abstract

Process Reward Models (PRMs) have demonstrated promising results in mathematical reasoning, but existing process annotation approaches, whether through human annotations or Monte Carlo simulations, remain computationally expensive. In this paper, we introduce Step COmpression for Process Estimation (SCOPE), a novel compression-based approach that significantly reduces annotation costs. We first translate natural language reasoning steps into code and normalize them through Abstract Syntax Tree, then merge equivalent steps to construct a prefix tree. Unlike simulation-based methods that waste numerous samples on estimation, SCOPE leverages a compression-based prefix tree where each root-to-leaf path serves as a training sample, reducing the complexity from $O(NMK)$ to $O(N)$. We construct a large-scale dataset containing 196K samples with only 5% of the computational resources required by previous methods. Empirical results demonstrate that PRMs trained on our dataset consistently outperform existing automated annotation approaches on both Best-of-N strategy and ProcessBench.

Figures

Figures reproduced from arXiv: 2505.14419 by the authors.

Figure 1
Figure 1. Comparison of PRMs training data construc [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Illustration of code translation and normalization. The solution of a math problem is first converted into [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Visualization of prefix tree construction process. Same-colored nodes indicate equivalent normalized step [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (2 more)
Figure 5
Figure 5. Figure 5: Comparison of time costs (GPU hours) for [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: AST structure of the ladder problem code. [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

39 extracted references · 2 canonical work pages

  1. [1]

    Alfred Aho, Monica Lam, Ravi Sethi, and Jeffrey D Ullman. 2007. https://dl.acm.org/doi/10.5555/1177220 Compilers: Principles, techniques and tools, 2nd editio

    work page doi:10.5555/1177220 2007

  2. [2]

    Reza Yazdani Aminabadi, Samyam Rajbhandari, Ammar Ahmad Awan, Cheng Li, Du Li, Elton Zheng, Olatunji Ruwase, Shaden Smith, Minjia Zhang, Jeff Rasley, et al. 2022. https://arxiv.org/abs/2207.00032 Deepspeed-inference: enabling efficient inference of transformer models at unprecedented scale . In SC22: International Conference for High Performance Computing...

    arXiv 2022

  3. [3]

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

    arXiv 2021

  4. [4]

    Ganqu Cui, Lifan Yuan, Zefan Wang, Hanbin Wang, Wendi Li, Bingxiang He, Yuchen Fan, Tianyu Yu, Qixin Xu, Weize Chen, et al. 2025. https://arxiv.org/abs/2502.01456 Process reinforcement through implicit rewards . arXiv preprint arXiv:2502.01456

    arXiv 2025

  5. [5]

    Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. 2024. https://arxiv.org/abs/2407.21783 The llama 3 herd of models . arXiv preprint arXiv:2407.21783

    arXiv 2024

  6. [6]

    Bofei Gao, Feifan Song, Zhe Yang, Zefan Cai, Yibo Miao, Qingxiu Dong, Lei Li, Chenghao Ma, Liang Chen, Runxin Xu, et al. 2024. https://arxiv.org/abs/2410.07985 Omni-math: A universal olympiad level mathematic benchmark for large language models . arXiv preprint arXiv:2410.07985

    arXiv 2024

  7. [7]

    Chaoqun He, Renjie Luo, Yuzhuo Bai, Shengding Hu, Zhen Leng Thai, Junhao Shen, Jinyi Hu, Xu Han, Yujie Huang, Yuxiang Zhang, et al. 2024. https://arxiv.org/abs/2402.14008 Olympiadbench: A challenging benchmark for promoting agi with olympiad-level bilingual multimodal scientific problems . arXiv preprint arXiv:2402.14008

    arXiv 2024

  8. [8]

    Dan Hendrycks, Collin Burns, Saurav Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2021. https://arxiv.org/abs/2103.03874 Measuring mathematical problem solving with the math dataset . NeurIPS

    arXiv 2021

Show all 39 references
  1. [9]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Kai Dang, et al. 2024. https://arxiv.org/abs/2409.12186 Qwen2. 5-coder technical report . arXiv preprint arXiv:2409.12186

    2024 arXiv

  2. [10]

    Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. 2024. https://arxiv.org/abs/2412.16720 Openai o1 system card . arXiv preprint arXiv:2412.16720

    2024 arXiv

  3. [11]

    Aitor Lewkowycz, Anders Andreassen, David Dohan, Ethan Dyer, Henryk Michalewski, Vinay Ramasesh, Ambrose Slone, Cem Anil, Imanol Schlag, Theo Gutman-Solo, et al. 2022. https://arxiv.org/abs/2206.14858 Solving quantitative reasoning problems with language models . Advances in N...

    2022 arXiv

  4. [12]

    Minpeng Liao, Wei Luo, Chengxi Li, Jing Wu, and Kai Fan. 2024. https://arxiv.org/abs/2401.08190 Mario: Math reasoning with code interpreter output--a reproducible pipeline . arXiv preprint arXiv:2401.08190

    2024 arXiv

  5. [13]

    Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. 2023. https://arxiv.org/abs/2305.20050 Let's verify step by step . arXiv preprint arXiv:2305.20050

    2023 arXiv

  6. [14]

    Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. 2024. https://arxiv.org/abs/2412.19437 Deepseek-v3 technical report . arXiv preprint arXiv:2412.19437

    2024 arXiv

  7. [15]

    I Loshchilov. 2017. https://arxiv.org/abs/1711.05101 Decoupled weight decay regularization . arXiv preprint arXiv:1711.05101

    2017 arXiv

  8. [16]

    Jianqiao Lu, Zhiyang Dou, WANG Hongru, Zeyu Cao, Jianbo Dai, Yunlong Feng, and Zhijiang Guo. 2024. https://arxiv.org/abs/2405.16802 Autopsv: Automated process-supervised verifier . In The Thirty-eighth Annual Conference on Neural Information Processing Systems

    2024 arXiv

  9. [17]

    Liangchen Luo, Yinxiao Liu, Rosanne Liu, Samrat Phatale, Harsh Lara, Yunxuan Li, Lei Shu, Yun Zhu, Lei Meng, Jiao Sun, et al. 2024. https://arxiv.org/abs/2406.06592 Improve mathematical reasoning in language models by automated process supervision . arXiv preprint arXiv:2406.06592

    2024 arXiv

  10. [18]

    Skywork o1 Team. 2024. https://huggingface.co/Skywork Skywork-o1 open series . https://huggingface.co/Skywork

    2024

  11. [19]

    Fengjun Pan, Xiaobao Wu, Zongrui Li, and Anh Tuan Luu. 2024. https://doi.org/10.18653/v1/2024.emnlp-main.794 Are LLM s good zero-shot fallacy classifiers? In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 14338--14364, Miami, Flor...

    2024 doi

  12. [20]

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. 2019. https://arxiv.org/abs/1912.01703 Pytorch: An imperative style, high-performance deep learning library . Advances in ne...

    2019 arXiv

  13. [21]

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. 2024. https://arxiv.org/abs/2402.03300 Deepseekmath: Pushing the limits of mathematical reasoning in open language models . arXiv preprint arXiv:2402.03300

    2024 arXiv

  14. [22]

    Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. 2024. https://arxiv.org/abs/2408.03314 Scaling llm test-time compute optimally can be more effective than scaling model parameters . arXiv preprint arXiv:2408.03314

    2024 arXiv

  15. [23]

    Zhengyang Tang, Xingxing Zhang, Benyou Wang, and Furu Wei. 2024. https://arxiv.org/abs/2403.02884 Mathscale: Scaling instruction tuning for mathematical reasoning . arXiv preprint arXiv:2403.02884

    2024 arXiv

  16. [24]

    Jonathan Uesato, Nate Kushman, Ramana Kumar, Francis Song, Noah Siegel, Lisa Wang, Antonia Creswell, Geoffrey Irving, and Irina Higgins. 2022. https://arxiv.org/abs/2211.14275 Solving math word problems with process-and outcome-based feedback . arXiv preprint arXiv:2211.14275

    2022 arXiv

  17. [25]

    Eric Wallace, Yizhong Wang, Sujian Li, Sameer Singh, and Matt Gardner. 2019. https://arxiv.org/abs/1909.07940 Do nlp models know numbers? probing numeracy in embeddings . arXiv preprint arXiv:1909.07940

    2019 arXiv

  18. [26]

    Peiyi Wang, Lei Li, Zhihong Shao, Runxin Xu, Damai Dai, Yifei Li, Deli Chen, Yu Wu, and Zhifang Sui. 2024. https://arxiv.org/abs/2312.08935 Math-shepherd: Verify and reinforce llms step-by-step without human annotations . In Proceedings of the 62nd Annual Meeting of the Associ...

    2024 arXiv

  19. [27]

    Xiaobao Wu. 2025. https://arxiv.org/abs/2505.02686 Sailing ai by the stars: A survey of learning from rewards in post-training and test-time scaling of large language models . arXiv preprint arXiv:2505.02686

    2025 arXiv

  20. [28]

    Xiaobao Wu, Chunping Li, Yan Zhu, and Yishu Miao. 2020. https://aclanthology.org/2020.emnlp-main.138.pdf Short text topic modeling with topic distribution quantization and negative sampling decoder . In Proceedings of the 2020 Conference on Empirical Methods in Natural Languag...

    2020

  21. [29]

    Xiaobao Wu, Thong Nguyen, and Anh Tuan Luu. 2024 a . https://doi.org/10.1007/s10462-023-10661-7 A survey on neural topic models: Methods, applications, and challenges . Artificial Intelligence Review

    2024 doi

  22. [30]

    Xiaobao Wu, Liangming Pan, William Yang Wang, and Anh Tuan Luu. 2024 b . https://doi.org/10.18653/v1/2024.emnlp-main.843 AKEW : Assessing knowledge editing in the wild . In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 15118--151...

    2024 doi

  23. [31]

    Xiaobao Wu, Liangming Pan, Yuxi Xie, Ruiwen Zhou, Shuai Zhao, Yubo Ma, Mingzhe Du, Rui Mao, Anh Tuan Luu, and William Yang Wang. 2024 c . https://arxiv.org/pdf/2412.13670 AntiLeak-Bench : Preventing data contamination by automatically constructing benchmarks with updated real-...

    2024 arXiv

  24. [32]

    Wei Xiong, Hanning Zhang, Nan Jiang, and Tong Zhang. 2024. An implementation of generative prm. https://github.com/RLHFlow/RLHF-Reward-Modeling

    2024

  25. [33]

    An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, Keming Lu, Mingfeng Xue, Runji Lin, Tianyu Liu, Xingzhang Ren, and Zhenru Zhang. 2024. https://arxiv.org/abs/2409.12122 Qwen2.5-math technical report: ...

    2024 arXiv

  26. [34]

    Fei Yu, Anningzhe Gao, and Benyou Wang. 2023. https://arxiv.org/abs/2311.09724 Outcome-supervised verifiers for planning in mathematical reasoning . arXiv preprint arXiv:2311.09724

    2023 arXiv

  27. [35]

    Lifan Yuan, Wendi Li, Huayu Chen, Ganqu Cui, Ning Ding, Kaiyan Zhang, Bowen Zhou, Zhiyuan Liu, and Hao Peng. 2024. https://arxiv.org/abs/2412.01981 Free process rewards without process labels . arXiv preprint arXiv:2412.01981

    2024 arXiv

  28. [36]

    Chujie Zheng, Zhenru Zhang, Beichen Zhang, Runji Lin, Keming Lu, Bowen Yu, Dayiheng Liu, Jingren Zhou, and Junyang Lin. 2024 a . https://arxiv.org/abs/2412.06559 Processbench: Identifying process errors in mathematical reasoning . arXiv preprint arXiv:2412.06559

    2024 arXiv

  29. [37]

    Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Sun, Jeff Huang, Cody Hao Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E Gonzalez, et al. 2024 b . https://arxiv.org/abs/2312.07104 Sglang: Efficient execution of structured language model programs . arXiv preprint a...

    2024 arXiv

  30. [38]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  31. [39]

    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...

Pith tools

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