Pith. sign in

REVIEW 5 major objections 8 minor 33 references

RePaCA: Leveraging Reasoning Large Language Models for Static Automated Patch Correctness Assessment

T0 review · 5 major / 8 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read A 3-billion-parameter reasoning language model, fine-tuned with GRPO on a chain-of-thought prompt, classifies overfitting code patches at 83.1% accuracy and outperforms prior static patch-correctness techniques while giving an explainable…

desk verdict A plausible first application of GRPO-based RL to static APCA with a likely-but-not-fully-demonstrated SOTA claim; worth serious review, but the missing LLM4PatchCorrect baseline and lack of variance keep the headline from being fully earned. read the letter →

arxiv 2507.22580 v2 pith:IM5WBG3R submitted 2025-07-30 cs.SE cs.AI

Marcos Fuster-Pena , David de-Fitero-Dominguez , Antonio Garcia-Cabot , Eva Garcia-Lopez This is my paper · ORCID
classification cs.SEcs.AI
keywords AutomatedProgramRepairPatchCorrectnessAssessmentLargeLanguageModelsChainofThoughtGRPOReinforcementLearningOverfittingpatchesStaticanalysis
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

Automated program repair tools often produce patches that pass the tests but do not actually fix the bug, and deciding which patches are overfitting is the bottleneck. This paper tries to show that the task can be solved statically, without executing tests, by a small reasoning language model prompted to compare the buggy and fixed code and think through the root cause before classifying the patch. The authors fine-tune a 3-billion-parameter code model with reinforcement learning (GRPO) and report state-of-the-art results on a standard Defects4J-derived benchmark: 83.1% accuracy and 84.8% F1-score, with stronger cross-dataset generalization than the previous leading static technique. If true, the practical gain is that an explainable, cheap-at-inference filter could sit inside an APR pipeline and reject overfitting patches before developers review them.

What carries the argument

The load-bearing mechanism is the GRPO reinforcement-learning loop applied to a chain-of-thought prompt. The prompt gives the model the buggy snippet, the fixed snippet, and instructions to analyze the difference, reason about the root cause, and finish with a binary answer in a <think>...</think> and <answer>...</answer> format. During training the model samples eight candidate responses per input; a format reward pays for correct tags and a keyword that expresses a verdict, and an accuracy reward pays 1.0 for correctly calling a patch correct and 2.0 for correctly calling it overfitting, compensating for the harder class. The chosen base model is Qwen2.5-Coder 3B, selected as the smallest size with enough reasoning ability to train stably under GRPO. This combination — no supervised fine-tuning, RL-shaped reasoning traces, and an explicit final verdict — is what the paper credits for the benchmark gains.

What would settle it

Run the same 5-fold evaluation on a freshly assembled set of APR-generated patches from bugs reported after the base model's training data was collected, and compare RePaCA against the same prompt without GRPO fine-tuning; if its accuracy drops to the level of the old baselines, the gain is memorization rather than reasoning.

Watch

Extended reading notes

Core claim

The paper's central claim is that patch correctness is a reasoning problem, not only a pattern-matching problem: given only the buggy and fixed code snippets, a language model that is explicitly trained to produce a chain of thought about the change can decide whether the patch addresses the root cause or merely satisfies the tests. After GRPO fine-tuning without a supervised step, the model reaches 83.1% accuracy, 84.0% precision, 85.7% recall, 84.8% F1, and 82.8% AUC on the 1,183-patch Small benchmark, beating APPT, CACHE, ODS, and Quatrain on every reported metric. Trained on Small and tested on the 49,694-patch Large dataset, it keeps 72.7% accuracy and 72.3% AUC, while APPT falls to 60.5% and 55.4%; the paper reads this as evidence that reasoning transfers across patch sources. The model's <think> block also turns each assessment into an inspectable explanation, which the paper presents as the first explainable static APCA technique.

Load-bearing premise

The reported accuracy assumes the base model did not already memorize the benchmark patches or their labels during pretraining, because the paper includes no check for such contamination.

Editorial extensions

If this is right

  • Static APCA can be cast as a reasoning task: a 3-billion-parameter model trained only with reinforcement learning beats the best prior static classifiers on the standard benchmark.
  • An APR pipeline can insert RePaCA right after patch generation and use it to filter overfitting patches before human review, reducing the manual screening burden.
  • The <think> block gives a per-patch rationale, so developers can inspect why a patch was rejected instead of trusting a black-box label.
  • The cross-dataset result implies that reasoning-based assessment transfers to patches from different sources and tools better than the embedding-based APPT baseline.
  • The asymmetric accuracy reward, 2.0 for detecting overfitting versus 1.0 for correct, is a workable way to counter class difficulty without collapsing precision or recall.

Reading between the lines

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

  • Beyond the paper: a contamination check on post-training-cutoff patches would tell whether the 83.1% reflects reasoning or memorized benchmark examples.
  • Beyond the paper: because the prompt and rewards are language-agnostic, the same recipe should transfer to non-Java APR benchmarks; a direct test would be training on a Python or C++ patch corpus.
  • Beyond the paper: majority voting over the model's multiple sampled generations at inference time could improve accuracy further, since the paper only mentions re-sampling to repair malformed outputs.
  • Beyond the paper: adding a reward that grades the quality of the <think> block itself, rather than only its format and final label, could reduce the observed contradictions between the reasoning and the verdict.
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 / 8 minor

Summary. The paper proposes RePaCA, a static APCA technique that fine-tunes a 3B-parameter reasoning LLM (Qwen2.5-Coder 3B) with GRPO. The model is prompted with buggy and fixed code snippets, asked to produce a chain-of-thought inside <think> tags, and then to answer 'correct' or 'overfitting' in <answer> tags. The method is evaluated on the APPT 'Small' dataset (1,183 Defects4J-derived patches) using 5-fold cross-validation, reporting 83.1% accuracy and 84.8% F1; and on a cross-dataset transfer setting (train on Small, test on Large), reporting 72.7% accuracy versus APPT's 60.5%. Two reasoning traces are presented to illustrate explainability.

Significance. If the reported numbers are reproducible, the work is a meaningful advance: this is, to my knowledge, the first application of GRPO to static patch correctness assessment, and the held-out 5-fold protocol on a standard benchmark gives the main comparison a plausible internal structure. The claimed gains over APPT and CACHE are consistent across several metrics, and the cross-dataset transfer result, if confirmed, is notable. However, the paper ships no code or trained model, reports no variance or significance tests, and the state-of-the-art claim rests on an incomplete baseline table. These gaps currently prevent me from endorsing the headline result. The explainability contribution is real in spirit but supported by only two hand-picked examples, one of which contains a factual error that the authors themselves acknowledge.

major comments (5)
  1. [Section 4.1, Table 4] Table 4 omits LLM4PatchCorrect [22], a static LLM-based APCA method that the authors cite and use to source ODS/Quatrain metrics and the APPT datasets. Because [22] is directly comparable and reports results on the same benchmark family, the 'state-of-the-art' claim in the abstract and Section 5.1 is not established unless that baseline is included or its exclusion is justified with concrete evidence that the comparison would be unfair.
  2. [Section 4.1, Table 4] No variance, per-fold results, or significance tests are reported for RePaCA or for any baseline, and the baseline numbers are copied from the original papers without demonstrating that the same 5-fold splits and evaluation protocols were used. The 3.4-point accuracy advantage over APPT could lie within cross-validation noise; the paper should report per-fold results, standard deviations, and a paired significance test (e.g., McNemar) for the RePaCA versus APPT comparison.
  3. [Section 3.5 and 4.1] No contamination check is reported. The Small dataset is derived from Defects4J and public GitHub patches, and the base model Qwen2.5-Coder was pretrained on web-scale public code; if exact patches or their labels appeared in pretraining, the 83.1% accuracy would partly reflect memorization rather than the reasoning capability the paper claims. The authors should report an overlap analysis between the benchmark instances and the pretraining corpus, or evaluate on newly collected, non-public patches.
  4. [Section 3.2 and 5.1] The claim that GRPO fine-tuning is 'critical' (Section 5.1) is not supported by an ablation. The paper does not compare against the unmodified Qwen2.5-Coder 3B base model, a supervised fine-tuning baseline, or an equal-reward variant, and the reward weights (1.0 for correct, 2.0 for overfitting) are tuned empirically with no sensitivity analysis. Without these comparisons, the contribution of the RL reward design and CoT prompting is not isolated.
  5. [Section 4.2, Table 5] The cross-dataset comparison retrains APPT internally, but the manuscript gives no details on the retraining protocol beyond 'the same hyperparameters used on their test' — no epochs, seeds, data splits, or variability are reported. The APPT result of 60.5% accuracy and 55.4% AUC may depend on these training choices, so the claimed superiority in generalization is not yet demonstrated robustly.
minor comments (8)
  1. [Section 2] Typo: 'relaying only on the original and patched code' should read 'relying only on the original and patched code'.
  2. [Section 3.6] Grammar: 'All has been done on the PyTorch framework' should be 'All training was done with the PyTorch framework'.
  3. [Section 4.3.1] The first reasoning example contains a factual error (the model calls ydotonscale2 a new variable even though it appears earlier in the snippet), which the authors acknowledge. Since explainability is a headline contribution, this weakness should be discussed more prominently, and ideally the paper should provide a quantitative evaluation of how often chain-of-thought rationales contain such errors.
  4. [Section 3.1 and 5.2] The 'approximately 1%' malformed-output rate is reported informally; please give exact counts and state how malformed outputs were treated when computing the metrics in Section 4.
  5. [Table 4] Precision and recall are missing for ODS and Quatrain; this should be stated in the caption or text, since it prevents a complete comparison across all metrics.
  6. [References] DeepSeek-R1 appears twice, as [16] and [21]; cite it once and renumber.
  7. [Section 6, Code 3] The example of an 'indistinguishable overfitting patch' appears garbled: the out.write('\\') line is duplicated. Please fix the formatting so the diff is clearly readable.
  8. [Section 5.1] The phrase 'unprecedented among current APCA techniques' is too strong given that only two reasoning examples are shown; suggest softening to 'not offered by prior static APCA techniques' or similar.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the accuracy reward is supervised by held-out ground-truth labels and the evaluation uses standard 5-fold cross-validation, so the reported results are not forced by construction.

full rationale

The paper's derivation chain is self-contained rather than circular. RePaCA is trained with GRPO using a format reward and an accuracy reward; the accuracy reward is directly supervised by the ground-truth correct/overfitting label, while the evaluation in Section 4.1 uses standard 5-fold cross-validation on the Small dataset, so the reported 83.1% accuracy and 84.8% F1 are measured on held-out folds rather than derived from the training labels by construction. The reward weights (1.0 for correct, 2.0 for overfitting) and hyperparameters such as the 20 epochs and learning rate are tuning choices, not fitted parameters that rename the evaluation target. The cross-dataset experiment in Section 4.2 also trains on Small and tests on Large, and APPT is retrained under the same protocol, so the comparison is not an artifact of the paper's own outputs. The manuscript's stated limitations, including occasional hallucinated reasoning, about 1% malformed outputs, and the absence of a reward that validates the reasoning content, are threats to validity rather than circular steps. The omission of LLM4PatchCorrect from the baseline table and the copying of baseline metrics from original papers are external-validity and completeness concerns, not cases where a prediction reduces to an input by definition. There is no self-citation chain, no imported uniqueness theorem, and no ansatz smuggled in via citation, so the circularity score is 0.

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

The central claim rests on the benchmark labels being correct, on the static APCA premise that code snippets suffice, on comparability of baseline numbers from earlier papers, and on the absence of pretraining contamination of the base model. The free parameters are the empirically chosen reward weights and training hyperparameters. No invented entities are introduced.

free parameters (6)
  • Accuracy reward for correct patches = 1.0
    Set in Table 1 and chosen after preliminary experimentation, not derived; it shapes the optimization objective.
  • Accuracy reward for overfitting patches = 2.0
    Selected empirically to counter the model's tendency to miss overfitting patches; directly affects the trained policy.
  • Training epochs = 20
    Chosen by observing convergence on a validation split during development; affects the final model weights.
  • GRPO group size = 8
    Number of candidate generations per prompt; a hyperparameter chosen for VRAM and training stability.
  • Sampling temperature = 0.6
    Hand-picked balance between diversity and determinism for generation.
  • Learning rate = 5e-5
    Taken from APPT and adopted without independent tuning; influences training dynamics.
assumptions (4)
  • domain assumption Benchmark labels in the CACHE/APPT datasets correctly distinguish overfitting from correct patches.
    The accuracy reward and all evaluation metrics rest on these labels; Section 3.5 inherits them without independent verification.
  • domain assumption Code snippets alone contain sufficient information to assess patch correctness.
    This is the static APCA premise stated in Section 1; if false, no static method can be reliable.
  • domain assumption Prior published baseline metrics were computed under the same 5-fold cross-validation protocol and comparable data filtering.
    Section 4.1 takes CACHE and APPT numbers from original papers and ODS and Quatrain metrics from LLM4PatchCorrect.
  • domain assumption Qwen2.5-Coder pretraining did not memorize the exact evaluation patches.
    No contamination check is reported; the benchmark is public Java code from Defects4J and GitHub, plausibly present in pretraining corpora.

how reviews work

0 comments
Cite this review

Pith. "Pith review of RePaCA: Leveraging Reasoning Large Language Models for Static Automated Patch Correctness Assessment." pith.science (2026). https://pith.science/paper/IM5WBG3R

@misc{pith2026250722580,
  author       = {Pith},
  title        = {Pith review of: RePaCA: Leveraging Reasoning Large Language Models for Static Automated Patch Correctness Assessment},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IM5WBG3R}},
  note         = {Machine review of arXiv:2507.22580}
}
read the original abstract

Automated Program Repair (APR) seeks to automatically correct software bugs without requiring human intervention. However, existing tools tend to generate patches that satisfy test cases without fixing the underlying bug, those are known as overfitting patches. To address this issue, Automated Patch Correctness Assessment (APCA) attempts to identify overfitting patches generated by APR tools. It can be solved as a static approach, meaning that no additional information is needed beyond the original and fixed code snippets. Current static techniques often struggle with reliability, flexibility and transparency. To address these issues, we introduce RePaCA, a novel static APCA technique that leverages Large Language Models (LLMs) specialized in thinking tasks. Our model is prompted with both buggy and fixed code snippets and guided to generate a Chain of Thought that analyses code differences, reasons about how the patch addresses the root cause, and ultimately provides a binary classification: correct or overfitting. To enhance these reasoning capabilities for the APCA task specifically, the LLM is finetuned using Reinforcement Learning with the Group Relative Policy Optimization algorithm. When evaluated on a standard Defects4J-derived test, our approach achieves state-of-the-art performance, with 83.1% accuracy and an 84.8% F1-score. Furthermore, our model demonstrates superior generalization capabilities when trained on different datasets, outperforming the leading technique. This reasoning capability also provides enhanced explainability for the patch assessment. These findings underscore the considerable promise of finetuned, reasoning LLMs to advance static APCA by enhancing accuracy, generalization, and explainability.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

33 extracted references · 15 canonical work pages

  1. [22]

    Leveraging Large Language Model for Automatic Patch Correctness Assessment,

    X. Zhou et al., “Leveraging Large Language Model for Automatic Patch Correctness Assessment,” IEEE Trans. Softw. Eng., vol. 50, no. 11, pp. 2865–2883, Nov. 2024, doi: 10.1109/TSE.2024.3452252

    work page arXiv 2024

  2. [1]

    This approach ensures a direct and fair comparison against leading techniques like APPT and CA CHE, which use the same evaluation framework

    This initial experiment is designed to rigorously evaluate RePaCA’s performance by following the standard 5 -fold cross-validation protocol on the 'Small' dataset, the established benchmark in the APCA community. This approach ensures a direct and fair comparison against leading techniques like APPT and CA CHE, which use the same evaluation framework. Fur...

    work page

  3. [2]

    We also present a new comparison of performance across datasets between the highest-performing model (APPT) and ours , to study the performance across different domains. Unlike CACHE, which trains on the large dataset and tests on the small dataset, we train on the smaller dataset and test on the larger one due to the significant training time req uired f...

    work page

  4. [3]

    The patch also introduces a new variable `ydotonscale2` that is not used anywhere in the original code, which is not a good practice

    In addition, we show two examples of the behavior of our model while classifying two patches, one correct and another overfitting, which are answered correctly by our model. We will also show the reasoning and explain why such reasoning is correct. 4.1 PERFORMANCE ON SMALL DATASET The performance of the static APCA techniques for the small dataset is pres...

    work page 2023

  5. [4]

    A Survey of Learning-based Automated Program Repair

    Q. Zhang, C. Fang, Y. Ma, W. Sun, and Z. Chen, “A Survey of Learning -based Automated Program Repair,” Nov. 01, 2023, arXiv: arXiv:2301.03270. doi: 10.48550/arXiv.2301.03270

    work page Pith review arXiv doi:10.48550/arxiv.2301.03270 2023

  6. [5]

    An analysis of patch plausibility and correctness for generate -and-validate patch generation systems,

    Z. Qi, F. Long, S. Achour, and M. Rinard, “An analysis of patch plausibility and correctness for generate -and-validate patch generation systems,” in Proceedings of the 2015 International Symposium on Software Testing and Analysi s, in ISSTA

    work page 2015

  7. [6]

    EvoSuite: automatic test suite generation for object - oriented software,

    G. Fraser and A. Arcuri, “EvoSuite: automatic test suite generation for object - oriented software,” in Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering , in ESEC/FSE ’11. New York, NY, USA: Association for Computing Machinery, Sep. 2011, pp. 416–419. doi: 10.1145/2025113.2025179. 17

    arXiv 2011

  8. [7]

    Automated patch correctness assessment: how far are we?,

    S. Wang et al., “Automated patch correctness assessment: how far are we?,” in Proceedings of the 35th IEEE/ACM International C onference on Automated Software Engineering, in ASE ’20. New York, NY, USA: Association for Computing Machinery, Jan. 2021, pp. 968–980. doi: 10.1145/3324884.3416590

    arXiv 2021

Show all 33 references
  1. [8]

    Is the cure worse than the disease? overfitting in automated program repair,

    E. K. Smith, E. T. Barr, C. Le Goues, and Y. Brun, “Is the cure worse than the disease? overfitting in automated program repair,” in Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering , in ESEC/FSE 2015. New York, NY, USA: Ass ociation for Comput...

    2015

  2. [9]

    Identifying test -suite-overfitted patches through test case generation,

    Q. Xin and S. P. Reiss, “Identifying test -suite-overfitted patches through test case generation,” in Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis, in ISSTA 2017. New York, NY, USA: Association for Computing Machinery, Jul. 2017,...

    2017

  3. [10]

    Invalidator: Automated Patch Correctness Assessment via Semantic and Syntactic Reasoning,

    “Invalidator: Automated Patch Correctness Assessment via Semantic and Syntactic Reasoning,” ResearchGate. Accessed: Mar. 13, 2025. [Online]. Available: https://www.researchgate.net/publication/369156342_Invalidator_Automated_Pat ch_Correctness_Assessment_via_Semantic_and_Synta...

    2025

  4. [11]

    Randoop: feedback -directed random testing for Java,

    C. Pacheco and M. D. Ernst, “Randoop: feedback -directed random testing for Java,” in Companion to the 22nd ACM SIGPLAN conference on Object -oriented programming systems and applications companion, in OOPSLA ’07. New York, NY, USA: Association for Computing Machinery, Oct. 20...

    2007

  5. [12]

    Identifying patch correctness in test-based program repair,

    Y. Xiong, X. Liu, M. Zeng, L. Zhang, and G. Huang, “Identifying patch correctness in test-based program repair,” in Proceedings of the 40th International Conference on Software Engineeri ng, in ICSE ’18. New York, NY, USA: Association for Computing Machinery, May 2018, pp. 789...

    2018

  6. [13]

    Context -Aware Code Change Embedding for Better Patch Correctness Assessment,

    B. Lin, S. Wang, M. Wen, and X. Mao, “Context -Aware Code Change Embedding for Better Patch Correctness Assessment,” ACM Trans Softw Eng Methodol , vol. 31, no. 3, p. 51:1-51:29, May 2022, doi: 10.1145/3505247

    2022 doi

  7. [14]

    Chain-of-Thought Prompting Elicits Reasoning in Large Language Models,

    J. Wei et al., “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models,” Jan. 10, 2023, arXiv: arXiv:2201.11903. doi: 10.48550/arXiv.2201.11903

    2023 doi arXiv

  8. [15]

    APPT: Boosting Automated Patch Correctness Prediction via Fine- Tuning Pre-Trained Models,

    Q. Zhang et al., “APPT: Boosting Automated Patch Correctness Prediction via Fine- Tuning Pre-Trained Models,” IEEE Trans. Softw. Eng., vol. 50, no. 3, pp. 474–494, Mar. 2024, doi: 10.1109/TSE.2024.3354969

    2024

  9. [16]

    Automated Classification of Overfitting Patches with Statically Extracted Code Features,

    H. Ye, J. Gu, M. Martinez, T. Durieux, and M. Monperrus, “Automated Classification of Overfitting Patches with Statically Extracted Code Features,” IEEE Trans. Softw. Eng., vol. 48, no. 8, pp. 2920–2938, Aug. 2022, doi: 10.1109/tse.2021.3071750

    2022

  10. [17]

    Is this Change the Answer to that Problem? Correlating Descriptions of Bug and Code Changes for Evaluating Patch Correctness,

    H. Tian et al., “Is this Change the Answer to that Problem? Correlating Descriptions of Bug and Code Changes for Evaluating Patch Correctness,” in Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering, Oct. 2022, pp. 1–13. doi: 10.1145/355...

    2022

  11. [18]

    BERT: Pre -training of Deep Bidirectional Transformers for Language Understanding,

    J. Devlin, M. -W. Chang, K. Lee, and K. Toutanova, “BERT: Pre -training of Deep Bidirectional Transformers for Language Understanding,” May 24, 2019, arXiv: arXiv:1810.04805. doi: 10.48550/arXiv.1810.04805

    2019 doi arXiv

  12. [19]

    DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models,

    Z. Shao et al., “DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models,” Apr. 27, 2024, arXiv: arXiv:2402.03300. doi: 10.48550/arXiv.2402.03300

    2024 doi arXiv

  13. [21]

    CodeBERT: A Pre -Trained Model for Programming and Natural Languages,

    Z. Feng et al. , “CodeBERT: A Pre -Trained Model for Programming and Natural Languages,” Sep. 18, 2020, arXiv: arXiv:2002.08155. doi: 10.48550/arXiv.2002.08155

    2020 doi arXiv

  14. [23]

    Proximal Policy Optimization Algorithms,

    J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov, “Proximal Policy Optimization Algorithms,” Aug. 28, 2017, arXiv: arXiv:1707.06347. doi: 10.48550/arXiv.1707.06347

    2017 doi arXiv

  15. [24]

    Strategic Prompting for Conversational Tas ks: A Comparative Analysis of Large Language Models Across Diverse Conversational Tasks,

    R. K. Joshi et al., “Strategic Prompting for Conversational Tas ks: A Comparative Analysis of Large Language Models Across Diverse Conversational Tasks,” Nov. 28, 2024, arXiv: arXiv:2411.17204. doi: 10.48550/arXiv.2411.17204

    2024 doi arXiv

  16. [25]

    DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning,

    DeepSeek-AI et al., “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning,” Jan. 22, 2025, arXiv: arXiv:2501.12948. doi: 10.48550/arXiv.2501.12948

    2025 doi arXiv

  17. [26]

    How Often Do Single -Statement Bugs Occur? The ManySStuBs4J Dataset,

    R.-M. Karampatsis and C. Sutton, “How Often Do Single -Statement Bugs Occur? The ManySStuBs4J Dataset,” in Proceedings of the 17th International Conference on Mining Software Repositories , Jun. 2020, pp. 573 –577. doi: 10.1145/3379597.3387491

    2020

  18. [27]

    Qwen2.5 Technical Report,

    Qwen et al., “Qwen2.5 Technical Report,” Jan. 03, 2025, arXiv: arXiv:2412.15115. doi: 10.48550/arXiv.2412.15115. 18

    2025 doi arXiv

  19. [28]

    Evaluating Representation Learning of Code Changes for Predicting Patch Correctness i n Program Repair,

    H. Tian et al., “Evaluating Representation Learning of Code Changes for Predicting Patch Correctness i n Program Repair,” Aug. 07, 2020, arXiv: arXiv:2008.02944. doi: 10.48550/arXiv.2008.02944

    2020 doi arXiv

  20. [29]

    Defects4J: a database of existing faults to enable controlled testing studies for Java programs,

    R. Just, D. Jalali, and M. D. Ernst, “Defects4J: a database of existing faults to enable controlled testing studies for Java programs,” in Proceedings of the 20 14 International Symposium on Software Testing and Analysis , in ISSTA 2014. New York, NY, USA: Association for Comp...

    2014

  21. [31]

    Empirical Review of J ava Program Repair Tools: A Large -Scale Experiment on 2,141 Bugs and 23,551 Repair Attempts,

    T. Durieux, F. Madeiral, M. Martinez, and R. Abreu, “Empirical Review of J ava Program Repair Tools: A Large -Scale Experiment on 2,141 Bugs and 23,551 Repair Attempts,” May 28, 2019, arXiv: arXiv:1905.11973. doi: 10.48550/arXiv.1905.11973

    2019 doi arXiv

  22. [32]

    Group Relative Policy Optimization for Image Captioning

    “Group Relative Policy Optimization for Image Captioning.” Accessed: May 12,

  23. [34]

    Automated patch assessment for program repair at scale,

    H. Ye, M. Martinez, and M. Monperrus, “Automated patch assessment for program repair at scale,” Empir. Softw. Eng. , vol. 26, no. 2, p. 20, Feb. 2021, doi: 10.1007/s10664-020-09920-w

    2021 doi

  24. [2015]

    2015, pp

    New York, NY, USA: Association for Computing Machinery, Jul. 2015, pp. 24–36. doi: 10.1145/2771783.2771791

    2015

  25. [2025]

    Available: https://arxiv.org/html/2503.01333v1

    [Online]. Available: https://arxiv.org/html/2503.01333v1

    arXiv

Pith tools

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