Pith. sign in

REVIEW 2 major objections 5 minor 48 references

Agentic LLMs that reason about program semantics and distill reusable strategies produce smaller reduced bug-triggering programs than prior reducers, including C-Reduce.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · grok-4.5

2026-07-12 00:05 UTC pith:VHVAHBZD

load-bearing objection Real advance over fixed-transform reduction and C-Reduce on average, but the Abstract’s “consistently smaller / first to beat C-Reduce” framing is mean-driven and overstated. the 2 major comments →

arxiv 2607.03766 v1 pith:VHVAHBZD submitted 2026-07-04 cs.SE

Semantic-aware and Self-improving Program Reduction via Agentic Large Language Models

Xintong Zhou , Hongxu Xu , Chunhao Liao , Puzhuo Liu , Yongqiang Tian , Chengnian Sun This is my paper
classification cs.SE
keywords program reductiontest-case minimizationagentic LLMscompiler debuggingsemantic-aware reductionself-improving systemslearned reducer
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Program reduction shrinks a bug-triggering program to a minimal form that still exhibits the bug, so compiler and interpreter developers can debug more easily. Existing tools either apply language-agnostic syntactic deletions or fixed language-specific heuristics; they do not understand the particular program’s semantics and they never learn from the reductions they perform. This paper recasts reduction as an exploratory reasoning loop: an LLM agent analyzes the program and property, proposes candidate edits, and keeps only those that still trigger the bug, while a second offline agent generalizes accepted edits into executable match-and-rewrite strategies that run without further LLM calls. Realized as PROJ, the approach yields programs that are roughly 36–39% smaller, on average, than the best prior reducer across 90 C, Rust, and JavaScript benchmarks, and is the first system shown to beat the long-standing C-Reduce baseline on C. Because the learned strategies accumulate, later cases become cheaper and more deterministic, turning reduction into a self-improving process rather than a static checklist.

Core claim

Treating program reduction as autonomous, feedback-driven reasoning by an LLM agent, then distilling successful case-specific edits into a growing pool of deterministic, property-guarded strategies, produces strictly smaller reduced programs than both syntax-guided and hand-engineered language-specific reducers while remaining efficient.

What carries the argument

The PROJ framework: a reducer agent that runs a two-level ReAct propose–check–iterate loop (with default size-decreasing and tactical exploration modes) plus a reflector agent that generalizes accepted records into match/rewrite strategies stored in a per-language learned reducer that is applied before every future agent session.

Load-bearing premise

A general-purpose language model, given only a property-checker oracle and a small tool interface, can invent sound case-specific semantic rewrites often enough, and the reflector’s generalized strategies stay useful on unseen programs, without any expert language engineering.

What would settle it

On a fresh held-out suite of bug-triggering C programs never used for strategy distillation, freeze the learned reducer after training and measure whether the full PROJ pipeline still produces mean token counts at least 20% smaller than C-Reduce; a clear failure of that margin would falsify the central claim.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Compiler and interpreter communities that require minimized test cases can obtain substantially smaller reports without manual further reduction.
  • Reduction knowledge need no longer be hand-crafted; it can be accumulated automatically from everyday use of the tool.
  • Once strategies exist for a language, a large fraction of future reductions can run deterministically and cheaply before any LLM is invoked.
  • The same agent-plus-reflector pattern can be applied to other oracle-guided program transformations that currently rely on fixed rule sets.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If strategy pools keep growing without saturation, long-running deployments will need automatic pruning or prioritization of rarely firing rules to avoid runtime bloat.
  • The same reflective loop could distill reduction knowledge across related languages that share syntactic patterns, rather than keeping strictly separate pools.
  • Because the property checker is the sole soundness gate, any improvement in checker speed or caching would multiply the agent’s effective search budget.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper proposes agentic program reduction and implements it in PROJ: a language-agnostic framework that first runs a syntax-guided AGR (Perses), then a deterministic learned reducer of distilled match/rewrite strategies, then a reducer agent that explores case-specific semantic edits in a two-level ReAct loop with default and exploration modes, and finally an offline reflector that generalizes successful edits into executable strategies. On 90 bug-triggering programs in C, Rust, and JavaScript, sequential multi-run evaluation reports mean reduced sizes of 82.2 / 117.7 / 23.3 tokens—39.0%, 36.0%, and 38.9% smaller than the best baseline on each suite—and claims PROJ is the first reducer to beat C-Reduce on C on average, with competitive efficiency and modest API cost. Ablations cover the two-level loop, reduction modes, LLM backends, harness vs general SWE agents, and held-out transfer of the learned reducer on C.

Significance. If the mean superiority and self-improving loop hold under independent replications, this is a substantial contribution to program reduction and compiler debugging tooling. Beating C-Reduce on average for C is a notable empirical milestone after years of specialized engineering; the reflector-to-learned-reducer design is a concrete, property-guarded form of experience accumulation that goes beyond fixed LLM transformation suites (LPR) and pure prompt memory. Strengths include a clear tool-boundary harness, multi-language evaluation, sequential multi-run protocol with reflector enabled, held-out C evaluation of the frozen learned reducer, and ablations isolating loop structure, modes, models, and harness (Table II, Figs. 3–7, Tables III–IV). The work is of clear interest to the software engineering and compiler-testing communities.

major comments (2)
  1. [Abstract; §IV-B, Table II] Abstract and §IV-B state that PROJ “consistently produces smaller reduced programs than all existing state-of-the-art reducers” and is “the first reducer that outperforms C-Reduce” on C (39.0% smaller mean). Table II shows the advantage is mean-driven, not case-consistent: C-5 is +90.2% vs C-Reduce (148.3 vs 78), C-11 +23.3%, C-27 +4.6%; several Rust rows lose to C-Reduce or Vulcan (e.g., Rust-4, Rust-17, Rust-20). Please replace “consistently” with accurate language (e.g., “on average / in the large majority of cases”), and report case-level win rates and worst-case regressions against each baseline so the central claim matches the table.
  2. [§IV-B Methodology; §IV-C, Figs. 5–6] RQ1 processes benchmarks sequentially with the reflector enabled, so later cases inherit strategies from earlier ones; the headline C mean (82.2 vs C-Reduce 135) therefore mixes cold agentic reasoning with a warming strategy pool. Figure 6 shows cold vs warm PROJ have similar final size on the same 30 programs, and Figure 5 shows held-out PROJ-w/-LR at 89 vs C-Reduce 140, but the paper never reports a full cold-start PROJ (no learned strategies) mean against C-Reduce/Vulcan/LPR on Benchmark-C-Train under the same multi-run protocol. Because “first to outperform C-Reduce” is load-bearing, please add that head-to-head (or clearly state that the claim is for the full sequential system only) so readers can separate agent reasoning from accumulated strategies.
minor comments (5)
  1. [Table II; §IV-B] Table II reports means over three shuffled orderings but no standard deviations or significance tests for R(#) or T(s). Adding dispersion (as in Fig. 3’s bands) would strengthen the mean comparisons.
  2. [§III-C; §IV-A] The exploration budget N is stated as e.g. N=5 in §III-C but not listed among the evaluation hyperparameters in §IV-A; please state the exact N used in all experiments.
  3. [§III-D; Fig. 4] Fig. 4’s strategy examples are helpful; a short count of how many proposed strategies failed verification or were rejected as case-specific would clarify reflector reliability.
  4. [§V; Fig. 3] §V notes strategy explosion as future work; a brief empirical note on learned-reducer wall-clock overhead as the pool grows (58 C strategies) would help readers assess practicality.
  5. [Abstract; throughout] Minor polish: “areducer agent” / “areflector agent” spacing in the Abstract; ensure PROJ is typeset consistently (PROJ vs PROJ).

Circularity Check

0 steps flagged

No circularity: empirical claims rest on external property checkers, objective token counts, and independent baselines; self-citations are background, not load-bearing for the result.

full rationale

The paper's central claims (smaller reduced programs than Perses/Vulcan/LPR/C-Reduce on 90 benchmarks; first to beat C-Reduce on C means) are purely experimental. Success is defined by an external property checker ψ (bug still triggers) plus lexical token count; neither is defined in terms of PROJ's agents, strategies, or LLM outputs. The learned reducer is built by distilling only property-checked edits, verified with multi-fixture tests, then frozen and applied to held-out C programs (RQ2). Sequential accumulation during RQ1 is an evaluation design choice, not a definitional loop that forces the reported sizes. Self-citations (Perses, Vulcan, LPR, etc.) supply baselines and the initial AGR stage; they do not supply uniqueness theorems, fitted parameters renamed as predictions, or ansatze that make the new results true by construction. No self-definitional equations, no fitted-input-as-prediction, no load-bearing uniqueness import. The derivation chain is therefore self-contained against external oracles and tools.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 3 invented entities

The central empirical claim rests on standard program-reduction problem framing, a property-checker oracle, an initial AGR (Perses), and several hand-chosen agent budgets, plus the domain bet that current LLMs can propose property-preserving semantic edits. No new physical entities; invented machinery is the agent architecture and learned-reducer artifact. Free parameters are control hyperparameters, not fits to the reported size metric.

free parameters (4)
  • I_max (outer iterations)
    Set to 3 by authors; controls how often the agent resets context. Directly affects search budget and final size.
  • A_max schedule (60/50/40 attempts)
    Hand-chosen decreasing attempt budget per iteration; total 150 attempts in ablations. Not derived from theory.
  • Exploration budget N
    Consecutive non-improving rounds before revert (N=5 in settings). Governs when temporary expansions are abandoned.
  • LLM backend choice (DeepSeek-V4-Flash default)
    Model selection is a free engineering choice; ablations show modest sensitivity but the main table uses one default.
axioms (5)
  • domain assumption A property checker ψ is available and correctly decides whether a candidate still triggers the target bug.
    Standard program-reduction premise used throughout §I and Algorithms 1–2; all acceptance decisions depend on it.
  • domain assumption An initial language-agnostic reducer (Perses) can shrink inputs to a scale where LLM agent reasoning is practical.
    Workflow step 1 (§III-A); PROJ is evaluated as a post-Perses pipeline, matching Vulcan/LPR practice.
  • ad hoc to paper LLMs can analyze program semantics relative to ψ and propose non-trivial, case-specific rewrites better than fixed rule sets.
    Core methodological bet of agentic reduction (§I Limitation 1; §III-C); not proved, only supported empirically.
  • ad hoc to paper Successful edits can be generalized into match/rewrite strategies that transfer across programs of the same language.
    Reflector design goal (§III-D; RQ2); held-out C results support it partially; Rust transfer is weak.
  • domain assumption Lexical token count is the right primary effectiveness metric for minimality.
    Metrics §IV-A; standard in the cited reduction literature but not the only possible notion of “minimal essential form.”
invented entities (3)
  • Reducer agent (two-level ReAct loop with default/exploration modes) no independent evidence
    purpose: Perform case-specific semantic-aware reduction under a property oracle.
    Architectural invention of the paper; no independent existence outside PROJ.
  • Reflector agent no independent evidence
    purpose: Distill accepted reductions into generalized strategies offline.
    Second collaborative component; defined only by this framework.
  • Learned reducer (per-language pool of executable match/rewrite passes) no independent evidence
    purpose: Apply accumulated strategies deterministically without LLM calls.
    Materialized artifact of reflection; evidence of utility is internal to the evaluation.

pith-pipeline@v1.1.0-grok45 · 25439 in / 3573 out tokens · 33265 ms · 2026-07-12T00:05:32.179684+00:00 · methodology

0 comments
read the original abstract

Reducing bug-triggering programs to their minimal essential form is a fundamental task in debugging language processors such as compilers and interpreters. Existing reduction techniques are limited by their reliance on predefined, syntax-driven transformations that lack semantic understanding of the target program, and by their inability to learn from past reduction experiences. We present a new approach that recasts program reduction as an autonomous reasoning task powered by agentic Large Language Models (LLMs). Instead of applying fixed transformation rules, our method enables an LLM to analyze program semantics, formulate reduction hypotheses, and iteratively refine its approach based on execution outcomes. Successful reduction experiences are further distilled into reusable strategies, allowing the system to continuously improve over time. We realize this approach in PROJ, a framework built around two collaborative components: a reducer agent that performs semantic-aware, case-specific program reduction, and a reflector agent that extracts and accumulates transferable reduction knowledge. Extensive experiments on 90 benchmarks spanning three programming languages show that PROJ consistently produces smaller reduced programs than all existing state-of-the-art reducers while maintaining high efficiency.

Figures

Figures reproduced from arXiv: 2607.03766 by Chengnian Sun, Chunhao Liao, Hongxu Xu, Puzhuo Liu, Xintong Zhou, Yongqiang Tian.

Figure 1
Figure 1. Figure 1: A motivating example of PROJ’s reduction process. Perses +PROJ produces 49 tokens, which is much smaller than 68 tokens produced by C-Reduce and 82 tokens produced by LPR. scalar variable. Thereafter the learned reducer applies these strategies automatically, with no LLM intervention, to any future program that exhibits the same pattern. III. APPROACH This section presents the workflow of PROJ with a detai… view at source ↗
Figure 2
Figure 2. Figure 2: The workflow of PROJ. TABLE I: Tools exposed to PROJ’s two LLM agents. Tool Description Reducer read_program Return the current program and its token count. read_best Return the smallest oracle-passing program so far. read_strategies List the learned reducer’s strategies. propose_candidate Submit & validate a candidate; update best on accept. revert_to_best Reset the working program to the best-so-far. dec… view at source ↗
Figure 3
Figure 3. Figure 3: The learned reducer (LR) during RQ1: accumulated strategies (left) and their share of the reduction (right) as cases are processed. Lines show the mean over three runs, and shaded bands indicate one standard deviation. We evaluate the generalizability of the learned reducer from two complementary angles. First, we analyze the learned reducer’s contribution during the RQ1 experiments. Since benchmarks are p… view at source ↗
Figure 4
Figure 4. Figure 4: Example strategies in the learned reducer distilled by the reflector agent. [PITH_FULL_IMAGE:figures/full_fig_p009_4.png] view at source ↗
Figure 6
Figure 6. Figure 6: Comparison of PROJ with and without the learned reducer. 30 training programs, and [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Ablation study on the two-level loop structure design. [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

48 extracted references · 3 linked inside Pith

  1. [1]

    Compiler validation via equivalence modulo inputs,

    V . Le, M. Afshari, and Z. Su, “Compiler validation via equivalence modulo inputs,”ACM Sigplan Notices, vol. 49, no. 6, pp. 216–226, 2014

    2014

  2. [2]

    Finding and understanding bugs in c compilers,

    X. Yang, Y . Chen, E. Eide, and J. Regehr, “Finding and understanding bugs in c compilers,” inProceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation, 2011, pp. 283–294

    2011

  3. [3]

    Finding compiler bugs via live code mutation,

    C. Sun, V . Le, and Z. Su, “Finding compiler bugs via live code mutation,” inProceedings of the 2016 ACM SIGPLAN international conference on object-oriented programming, systems, languages, and applications, 2016, pp. 849–863

    2016

  4. [4]

    Random testing for c and c++ compilers with yarpgen,

    V . Livinskii, D. Babokin, and J. Regehr, “Random testing for c and c++ compilers with yarpgen,”Proceedings of the ACM on Programming Languages, vol. 4, no. OOPSLA, pp. 1–25, 2020

    2020

  5. [5]

    Many-core compiler fuzzing,

    C. Lidbury, A. Lascu, N. Chong, and A. F. Donaldson, “Many-core compiler fuzzing,”ACM SIGPLAN Notices, vol. 50, no. 6, pp. 65–76, 2015

    2015

  6. [6]

    (2026) A guide to testcase reduction

    GCC-Wiki. (2026) A guide to testcase reduction. [Online]. Available: https://gcc.gnu.org/wiki/A guide to testcase reduction

    2026

  7. [7]

    (2026) How to submit an llvm bug report

    LLVM. (2026) How to submit an llvm bug report. [Online]. Available: https://llvm.org/docs/HowToSubmitABug.html

    2026

  8. [8]

    (2026) Bug report

    JerryScript. (2026) Bug report. [Online]. Avail- able: https://github.com/jerryscript-project/jerryscript/blob/master/ .github/ISSUE TEMPLATE/bug report.md

    2026

  9. [9]

    (2026) Bug report

    CPython. (2026) Bug report. [Online]. Avail- able: https://github.com/python/cpython/issues/new?assignees=&labels= type-bug&template=bug.md

    2026

  10. [10]

    Test-case reduction for c compiler bugs,

    J. Regehr, Y . Chen, P. Cuoq, E. Eide, C. Ellison, and X. Yang, “Test-case reduction for c compiler bugs,” inProceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation, 2012, pp. 335–346

    2012

  11. [11]

    Perses: Syntax-guided program reduction,

    C. Sun, Y . Li, Q. Zhang, T. Gu, and Z. Su, “Perses: Syntax-guided program reduction,” inProceedings of the 40th International Conference on Software Engineering, 2018, pp. 361–371

    2018

  12. [12]

    Pushing the limit of 1-minimality of language-agnostic program reduction,

    Z. Xu, Y . Tian, M. Zhang, G. Zhao, Y . Jiang, and C. Sun, “Pushing the limit of 1-minimality of language-agnostic program reduction,” Proceedings of the ACM on Programming Languages, vol. 7, no. OOPSLA1, pp. 636–664, 2023

    2023

  13. [13]

    Boosting program reduction with the missing piece of syntax-guided transformations,

    Z. Xu, Y . Tian, M. Zhang, and C. Sun, “Boosting program reduction with the missing piece of syntax-guided transformations,”Proceedings of the ACM on Programming Languages, vol. 9, no. OOPSLA2, pp. 86–112, 2025

    2025

  14. [14]

    T- rec: Fine-grained language-agnostic program reduction guided by lexical syntax,

    Z. Xu, Y . Tian, M. Zhang, J. Zhang, P. Liu, Y . Jiang, and C. Sun, “T- rec: Fine-grained language-agnostic program reduction guided by lexical syntax,”ACM Transactions on Software Engineering and Methodology, vol. 34, no. 2, pp. 1–31, 2025

    2025

  15. [15]

    Lpr: Large language models-aided program reduction,

    M. Zhang, Y . Tian, Z. Xu, Y . Dong, S. H. Tan, and C. Sun, “Lpr: Large language models-aided program reduction,” inProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, 2024, pp. 261–273

    2024

  16. [16]

    Virtual register defs don’t dominate all uses

    LLVM Project. (2026) [LLVM][RISCV][RVV] MachineVerifier failure “Virtual register defs don’t dominate all uses” with RVV vector stores at -O2/-O3 -flto. GitHub issue #198755. [Online]. Available: https://github.com/llvm/llvm-project/issues/198755

    2026

  17. [17]

    (2026) GCC Bugzilla Report 125538: gfortran ICE with -std=f2008 and associates

    GCC Bugzilla community. (2026) GCC Bugzilla Report 125538: gfortran ICE with -std=f2008 and associates. Bugzilla report #125538. [Online]. Available: https://gcc.gnu.org/bugzilla/show bug. cgi?id=125538

    2026

  18. [18]

    Latra: A template- based language-agnostic transformation framework for effective program reduction,

    Z. Xu, Y . Wang, Y . Tian, M. Zhang, and C. Sun, “Latra: A template- based language-agnostic transformation framework for effective program reduction,” in2025 40th IEEE/ACM International Conference on Auto- mated Software Engineering (ASE). IEEE, 2025, pp. 2274–2285

    2025

  19. [19]

    React: Synergizing reasoning and acting in language models,

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y . Cao, “React: Synergizing reasoning and acting in language models,”arXiv preprint arXiv:2210.03629, 2022

    Pith/arXiv arXiv 2022

  20. [20]

    Bugzilla

    L. Bugzilla. (2016) Bug 27747 - clang crashes on valid code at -o1 and above on x86 64-linux-gnu. [Online]. Available: https: //bugs.llvm.org/show bug.cgi?id=27747

    2016

  21. [21]

    Re- flexion: Language agents with verbal reinforcement learning,

    N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao, “Re- flexion: Language agents with verbal reinforcement learning,”Advances in neural information processing systems, vol. 36, pp. 8634–8652, 2023

    2023

  22. [22]

    V oyager: An open-ended embodied agent with large language models,

    G. Wang, Y . Xie, Y . Jiang, A. Mandlekar, C. Xiao, Y . Zhu, L. Fan, and A. Anandkumar, “V oyager: An open-ended embodied agent with large language models,”arXiv preprint arXiv:2305.16291, 2023

    Pith/arXiv arXiv 2023

  23. [23]

    Flashmemory-deepseek-v4: Lightning index ultra-long context via lookahead sparse attention,

    Y . Wang, Q. Zhang, J. Yu, T. Liang, D. Ma, X. Hu, Z. Lin, C. Li, Z. Wang, J. Liet al., “Flashmemory-deepseek-v4: Lightning index ultra-long context via lookahead sparse attention,”arXiv preprint arXiv:2606.09079, 2026

    Pith/arXiv arXiv 2026

  24. [24]

    Mimo-v2.5: Native omnimodal mixture- of-experts model with agentic capabilities,

    Xiaomi MiMo Team, “Mimo-v2.5: Native omnimodal mixture- of-experts model with agentic capabilities,” https://huggingface.co/ XiaomiMiMo/MiMo-V2.5, 2026

    2026

  25. [25]

    Minimax-m3: Large-scale multimodal foundation model,

    MiniMax AI, “Minimax-m3: Large-scale multimodal foundation model,” https://www.minimax.io/blog/minimax-m3, 2026

    2026

  26. [26]

    Swe-agent: Agent-computer interfaces enable automated soft- ware engineering,

    J. Yang, C. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “Swe-agent: Agent-computer interfaces enable automated soft- ware engineering,”Advances in Neural Information Processing Systems, vol. 37, pp. 50 528–50 652, 2024

    2024

  27. [27]

    Aider: Ai pair programming in your terminal,

    P. Gauthier, “Aider: Ai pair programming in your terminal,” https: //github.com/aider-ai/aider, 2025, gitHub repository

    2025

  28. [28]

    Simplifying and isolating failure-inducing input,

    A. Zeller and R. Hildebrandt, “Simplifying and isolating failure-inducing input,”IEEE Transactions on software engineering, vol. 28, no. 2, pp. 183–200, 2002

    2002

  29. [29]

    Hdd: hierarchical delta debugging,

    G. Misherghi and Z. Su, “Hdd: hierarchical delta debugging,” inPro- ceedings of the 28th international conference on Software engineering, 2006, pp. 142–151

    2006

  30. [30]

    ddsmt: a delta debugger for the smt-lib v2 format,

    A. Niemetz and A. Biere, “ddsmt: a delta debugger for the smt-lib v2 format,” inProceedings of the 11th International Workshop on Satisfiability Modulo Theories, SMT, 2013, pp. 8–9

    2013

  31. [31]

    Hddr: a recursive variant of the hierarchical delta debugging algorithm,

    ´A. Kiss, R. Hodov´an, and T. Gyim´othy, “Hddr: a recursive variant of the hierarchical delta debugging algorithm,” inProceedings of the 9th ACM SIGSOFT International Workshop on Automating TEST Case Design, Selection, and Evaluation, 2018, pp. 16–22

    2018

  32. [32]

    Ppr: Pairwise program reduction,

    M. Zhang, Z. Xu, Y . Tian, Y . Jiang, and C. Sun, “Ppr: Pairwise program reduction,” inProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2023, pp. 338–349

    2023

  33. [33]

    Probabilistic delta debugging,

    G. Wang, R. Shen, J. Chen, Y . Xiong, and L. Zhang, “Probabilistic delta debugging,” inProceedings of the 29th ACM joint meeting on european software engineering conference and symposium on the foundations of software engineering, 2021, pp. 881–892

    2021

  34. [34]

    Toward a better understanding of probabilistic delta debugging,

    M. Zhang, Z. Xu, Y . Tian, X. Cheng, and C. Sun, “Toward a better understanding of probabilistic delta debugging,” in2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 2025, pp. 2024–2035

    2025

  35. [35]

    Wdd: Weighted delta debugging,

    X. Zhou, Z. Xu, M. Zhang, Y . Tian, and C. Sun, “Wdd: Weighted delta debugging,” in2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE), 2025, pp. 1592–1603

    2025

  36. [36]

    Ad hoc syntax-guided program reduction,

    J. L. Tian, M. Zhang, Z. Xu, Y . Tian, Y . Dong, and C. Sun, “Ad hoc syntax-guided program reduction,” inProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2023, pp. 2137–2141

    2023

  37. [37]

    On the caching schemes to speed up program reduction,

    Y . Tian, X. Zhang, Y . Dong, Z. Xu, M. Zhang, Y . Jiang, S.-C. Cheung, and C. Sun, “On the caching schemes to speed up program reduction,” ACM Transactions on Software Engineering and Methodology, vol. 33, no. 1, pp. 1–30, 2023

    2023

  38. [38]

    Binary reduction of dependency graphs,

    C. G. Kalhauge and J. Palsberg, “Binary reduction of dependency graphs,” inProceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2019, pp. 556–566

    2019

  39. [39]

    The mutators reloaded: Fuzzing compilers with large language model generated mutation operators,

    X. Ou, C. Li, Y . Jiang, and C. Xu, “The mutators reloaded: Fuzzing compilers with large language model generated mutation operators,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 4, 2024, pp. 298–312

    2024

  40. [40]

    Whitefox: White-box compiler fuzzing empowered by large language models,

    C. Yang, Y . Deng, R. Lu, J. Yao, J. Liu, R. Jabbarvand, and L. Zhang, “Whitefox: White-box compiler fuzzing empowered by large language models,”Proceedings of the ACM on Programming Languages, vol. 8, no. OOPSLA2, pp. 709–735, 2024

    2024

  41. [41]

    Interleaving large language models for compiler testing,

    Y . Ni and S. Li, “Interleaving large language models for compiler testing,”Proceedings of the ACM on Programming Languages, vol. 9, no. OOPSLA2, pp. 815–841, 2025

    2025

  42. [42]

    Llm-based code generation method for golang compiler testing,

    Q. Gu, “Llm-based code generation method for golang compiler testing,” inProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2023, pp. 2201–2203

    2023

  43. [43]

    Kitten: A simple yet effective baseline for evaluating llm-based compiler testing techniques,

    Y . Xie, Z. Xu, Y . Tian, M. Zhou, X. Zhou, and C. Sun, “Kitten: A simple yet effective baseline for evaluating llm-based compiler testing techniques,” inProceedings of the 34th ACM SIGSOFT International Symposium on Software Testing and Analysis, 2025, pp. 21–25

    2025

  44. [44]

    Optfuzz: Enhancing compiler testing via llm-powered compilation option generation,

    Y . Huang, Y . Yang, M. Sun, J. Wu, Q. Li, Z. Lu, and Y . Zhou, “Optfuzz: Enhancing compiler testing via llm-powered compilation option generation,”ACM Transactions on Software Engineering and Methodology

  45. [45]

    Lpo: Discovering missed peephole optimizations with large language models,

    Z. Xu, H. Xu, Y . Tian, X. Zhou, and C. Sun, “Lpo: Discovering missed peephole optimizations with large language models,” inProceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, 2026, pp. 1136–1150

    2026

  46. [46]

    Leveraging large lan- guage models for generalizing peephole optimizations,

    C. Liao, H. Xu, X. Zhou, Z. Xu, and C. Sun, “Leveraging large lan- guage models for generalizing peephole optimizations,”arXiv preprint arXiv:2603.18477, 2026

    arXiv 2026

  47. [47]

    Llm- vectorizer: Llm-based verified loop vectorizer,

    J. Taneja, A. Laird, C. Yan, M. Musuvathi, and S. K. Lahiri, “Llm- vectorizer: Llm-based verified loop vectorizer,” inProceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization, 2025, pp. 137–149

    2025

  48. [48]

    Agentic harness for real- world compilers,

    Y . Zheng, C. Li, S. Li, Y . Zhang, and Z. Su, “Agentic harness for real- world compilers,”arXiv preprint arXiv:2603.20075, 2026

    arXiv 2026