Pith. sign in

REVIEW 3 major objections 98 references

GP-Tree replaces coarse bounding boxes with fine grid cells in a prefix tree, speeding spatial queries by up to 10x.

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-15 13:11 UTC pith:BMRBW7PB

load-bearing objection Wrong full text was supplied for GP-Tree; only the abstract is real, so the order-of-magnitude claim cannot be audited and the paper is not reviewable yet. the 3 major comments →

arxiv 2603.07517 v2 pith:BMRBW7PB submitted 2026-03-08 cs.DB cs.IR

GP-Tree: An in-memory spatial index combining adaptive grid cells with a prefix tree for efficient spatial querying

Xiangyang Yang , Xuefeng Guan , Lanxue Dang , Yi Xie , Qingyang Xu , Huayi Wu , Jiayao Wang This is my paper
classification cs.DB cs.IR
keywords spatial indexgrid cellsprefix treeGP-Treerange queryk-nearest neighborminimum bounding rectanglein-memory indexing
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.

Traditional spatial indexes such as R-trees and Quad-trees rely on minimum bounding rectangles that are too coarse for complex shapes like district boundaries or trajectories, so they waste work on false candidates. GP-Tree instead approximates each object by a set of adaptive grid cells and stores those cells inside a prefix tree that exploits shared hierarchical encodings. The finer approximation improves filtering accuracy while the tree structure and two optimizations (pruning and node packing) cut both search paths and memory. The same index supports range, distance and k-nearest-neighbor queries. On real-world data the approach delivers up to an order-of-magnitude faster queries than the classic indexes.

Core claim

Organizing fine-grained adaptive grid-cell approximations of spatial objects inside a prefix tree, together with pruning and node-optimization strategies, yields a spatial index whose filtering power and query speed substantially surpass those of MBR-based indexes such as STR-Tree and Quad-Tree, reaching order-of-magnitude gains on real data for range, distance and k-NN queries.

What carries the argument

GP-Tree: an in-memory index that maps each spatial object to a set of adaptive grid cells whose hierarchical encodings are stored as paths in a prefix tree; shared prefixes collapse common ancestors, while pruning and node packing further shrink the search space and memory footprint.

Load-bearing premise

The accuracy gain from cell-based approximations is large enough that the extra construction and memory cost still leaves a net win over classic MBR indexes on realistic workloads.

What would settle it

Measure wall-clock time, peak memory and false-positive rate for range, distance and k-NN queries on the same real-world datasets when objects are indexed by GP-Tree versus STR-Tree and Quad-Tree; if the speedup disappears or memory balloons, the central claim fails.

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

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

3 major / 0 minor

Summary. The submission under review is titled GP-Tree and claims a new in-memory spatial index that approximates complex spatial objects (e.g., district boundaries, trajectories) by adaptive grid cells rather than coarse MBRs, organizes those cells in a prefix tree that exploits hierarchical cell encodings, and adds pruning and node optimizations. The abstract asserts that this design improves filtering accuracy and yields up to an order-of-magnitude better efficiency than traditional indexes (STR-Tree, Quad-Tree) on range, distance, and k-NN queries over real-world datasets. However, the full manuscript body supplied with this review package is an entirely different paper (an empirical study of code representations for automated patch correctness assessment, arXiv:2603.07520). Consequently only the GP-Tree abstract is available for assessment; no algorithms, complexity analysis, construction/memory costs, workloads, baseline configurations, or result tables for GP-Tree are present.

Significance. If the abstract’s claims held under a fair experimental evaluation, GP-Tree would be a meaningful contribution to spatial indexing: fine-grained cell approximations for complex geometries and a prefix-tree organization are natural responses to well-known MBR filtering weaknesses, and order-of-magnitude query gains would matter for large-scale GIS and trajectory workloads. Those strengths cannot be credited on the present package, because the supporting design, analysis, and experiments are missing. The significance of the work therefore remains conditional on a correct, complete manuscript.

major comments (3)
  1. Manuscript integrity: the full text provided does not match the paper under review (title/abstract of GP-Tree / arXiv:2603.07517). The body is the unrelated APCA code-representation study. Without the actual GP-Tree sections on index structure, encoding, pruning, query algorithms, and experiments, the central order-of-magnitude claim cannot be audited at all.
  2. Abstract-only empirical claim: the strongest claim (up to ~10× query efficiency vs STR-Tree/Quad-Tree via adaptive grid cells + prefix tree + pruning) rests entirely on “extensive experiments on real-world datasets.” No datasets, query workloads, baseline configurations, construction time, memory footprint, or result tables are available, so it is impossible to check whether finer approximations reduce candidates enough to dominate end-to-end latency after build and space cost, or whether the comparison is fair.
  3. Load-bearing free parameters: adaptive grid resolution / cell-size policy and pruning/node-optimization thresholds are free parameters of the design. Their effect on filtering quality, memory, and query time is central to the claimed gains but is not specified or evaluated in any available text.

Circularity Check

0 steps flagged

No circular derivation: GP-Tree's order-of-magnitude claim is a standard empirical systems result, not forced by definition or self-citation; full text mismatch prevents deeper chain inspection but abstract shows no circularity patterns.

full rationale

The paper (as given by abstract and title) proposes an in-memory spatial index (adaptive grid-cell approximations organized in a prefix tree, with pruning/node optimization) and claims superior range/distance/k-NN query efficiency versus STR-Tree and Quad-Tree on real-world data. That claim is an empirical performance comparison (build index, run queries, measure latency), not a first-principles derivation of a quantity that is then 'predicted' from fitted inputs, nor a uniqueness theorem imported from the authors, nor a renaming of a known identity. No equations, fitted parameters re-labeled as predictions, or load-bearing self-citations appear in the available abstract. The CACHEABLE full-manuscript block is the unrelated APCA code-representation paper (2603.07520), so no GP-Tree algorithms, complexity proofs, or result tables can be checked for hidden circular steps; absence of those materials does not create circularity—it only leaves the empirical claim unverified. Under the stated rules, honest non-finding applies: score 0, empty steps.

Axiom & Free-Parameter Ledger

2 free parameters · 3 axioms · 1 invented entities

Abstract-only review of a systems index paper. Load-bearing content is design choices and empirical assumptions rather than mathematical axioms. Free parameters for grid resolution, pruning thresholds, and node packing are implied but not quantified. No invented physical entities.

free parameters (2)
  • Adaptive grid resolution / cell-size policy
    Abstract relies on 'adaptive grid cells' without stating how cell size is chosen; this policy typically dominates filter quality vs memory and is effectively a free design parameter.
  • Tree pruning and node-optimization thresholds
    Named optimizations that reduce paths and memory; without stated criteria they are free knobs that can be tuned to the evaluation workloads.
axioms (3)
  • domain assumption Fine-grained cell approximations of complex spatial objects yield substantially better filter selectivity than MBRs for the target query mix.
    Central premise of the abstract; if false for the workloads, the performance claim collapses.
  • domain assumption Shared hierarchical prefixes in grid encodings make a prefix-tree organization efficient for both storage and search.
    Stated mechanism for data organization and query efficiency; standard for hierarchical codes but still an assumption about workload locality and encoding design.
  • domain assumption In-memory index construction and residency are acceptable for the intended large-scale datasets.
    Paper positions GP-Tree as in-memory; scalability claims depend on this regime.
invented entities (1)
  • GP-Tree index structure no independent evidence
    purpose: Organize adaptive grid-cell approximations of spatial objects in a prefix tree with pruning/node optimizations to support range, distance, and k-NN queries.
    The paper's primary proposed artifact; independent evidence would be public code, formal complexity bounds, or third-party reimplementation—not available in the abstract.

pith-pipeline@v1.1.0-grok45 · 34805 in / 2591 out tokens · 29744 ms · 2026-07-15T13:11:48.659083+00:00 · methodology

0 comments
read the original abstract

Efficient spatial indexing is crucial for processing large-scale spatial data. Traditional spatial indexes, such as STR-Tree and Quad-Tree, organize spatial objects based on coarse approximations, such as their minimum bounding rectangles (MBRs). However, this coarse representation is inadequate for complex spatial objects (e.g., district boundaries and trajectories), limiting filtering accuracy and query performance of spatial indexes. To address these limitations, we propose GP-Tree, a fine-grained spatial index that organizes approximated grid cells of spatial objects into a prefix tree structure. GP-Tree enhances filtering ability by replacing coarse MBRs with fine-grained cell-based approximations of spatial objects. The prefix tree structure optimizes data organization and query efficiency by leveraging the shared prefixes in the hierarchical grid cell encodings between parent and child cells. Additionally, we introduce optimization strategies, including tree pruning and node optimization, to reduce search paths and memory consumption, further enhancing GP-Tree's performance. Finally, we implement a variety of spatial query operations on GP-Tree, including range queries, distance queries, and k-nearest neighbor queries. Extensive experiments on real-world datasets demonstrate that GP-Tree significantly outperforms traditional spatial indexes, achieving up to an order-of-magnitude improvement in query efficiency.

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

98 extracted references · 7 linked inside Pith

  1. [1]

    Leonhard Applis, Yuntong Zhang, Shanchao Liang, Nan Jiang, Lin Tan, and Abhik Roychoudhury. 2026. Unified Software Engineering agent as AI Software Engineer. InProceedings of the 48th IEEE/ACM International Conference on Software Engineering. IEEE, 1–12

    2026

  2. [2]

    Authors. 2026. Replication Package. site: https://anonymous.4open.science/r/APCARepresentation

    2026

  3. [3]

    Tom Britton, Lisa Jeng, Graham Carver, Paul Cheak, and Tomer Katzenellenbogen. 2013. Reversible debugging software. Judge Bus. School, Univ. Cambridge, Cambridge, UK, Tech. Rep229 (2013)

    2013

  4. [4]

    Tianqi Chen and Carlos Guestrin. 2016. XGBoost: A scalable tree boosting system. InProceedings of the 22nd ACM Sigkdd International Conference on Knowledge Discovery and Data Mining. 785–794

    2016

  5. [5]

    Zimin Chen, Steve Kommrusch, Michele Tufano, Louis-Noël Pouchet, Denys Poshyvanyk, and Martin Monperrus. 2019. Sequencer: Sequence-to-sequence learning for end-to-end program repair.IEEE Transactions on Software Engineering 47, 9 (2019), 1943–1959. , Vol. 1, No. 1, Article . Publication date: April 2026. 24 Quanjun Zhang, Haichuan Hu, Chunrong Fang, Ye Sh...

    2019

  6. [6]

    Corinna Cortes and Vladimir Vapnik. 1995. Support-vector networks.Machine Learning20, 3 (1995), 273–297

    1995

  7. [7]

    Yukun Dong, Xiaotong Cheng, Yufei Yang, Lulu Zhang, Shuqi Wang, and Lingjie Kong. 2024. A Method to Identify Overfitting Program Repair Patches Based on Expression Tree.Science of Computer Programming(2024), 103105

    2024

  8. [8]

    Thomas Durieux and Martin Monperrus. 2016. DynaMoth: Dynamic Code Synthesis for Automatic Program Repair. In Proceedings of the 11th International Workshop on Automation of Software Test. 85–91

    2016

  9. [9]

    Luca Gazzola, Daniela Micucci, and Leonardo Mariani. 2019. Automatic Software Repair: A Survey.IEEE Transactions on Software Engineering45, 1 (2019), 34–67

    2019

  10. [10]

    Ali Ghanbari and Andrian Marcus. 2022. Patch correctness assessment in automated program repair based on the impact of patches on production and test code. InProceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis. 654–665

    2022

  11. [11]

    David J Hand and Keming Yu. 2001. Idiot’s Bayes—not so stupid after all?International Statistical Review69, 3 (2001), 385–398

    2001

  12. [12]

    M Hossain. 2018. Challenges Of Software Quality Assurance And Testing.International Journal of Software Engineering and Computer Systems4, 1 (2018), 133–144

    2018

  13. [13]

    Elkhan Ismayilzada, Md Mazba Ur Rahman, Dongsun Kim, and Jooyong Yi. 2023. Poracle: Testing Patches under Preservation Conditions to Combat the Overfitting Problem of Program Repair.ACM Transactions on Software Engineering and Methodology33, 2 (2023), 1–39

    2023

  14. [14]

    Jiajun Jiang, Yingfei Xiong, Hongyu Zhang, Qing Gao, and Xiangqun Chen. 2018. Shaping Program Repair Space with Existing Patches and Similar Code. InProceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. 298–309

    2018

  15. [15]

    Nan Jiang, Thibaud Lutellier, Yiling Lou, Lin Tan, Dan Goldwasser, and Xiangyu Zhang. 2023. KNOD: Domain Knowledge Distilled Tree Decoder for Automated Program Repair. In2023 IEEE/ACM 45th International Conference on Software Engineering. IEEE, 1251–1263

    2023

  16. [16]

    Nan Jiang, Thibaud Lutellier, and Lin Tan. 2021. CURE: Code-Aware Neural Machine Translation for Automatic Program Repair. InProceedings of the 43rd IEEE/ACM International Conference on Software Engineering. 1161–1173

    2021

  17. [17]

    René Just, Darioush Jalali, and Michael D Ernst. 2014. Defects4j: A Database of Existing Faults to Enable Controlled Testing Studies for Java Programs. InProceedings of the 23rd International Symposium on Software Testing and Analysis. 437–440

    2014

  18. [18]

    Thomas N Kipf and Max Welling. 2016. Semi-supervised classification with graph convolutional networks.arXiv preprint arXiv:1609.02907(2016)

    Pith/arXiv arXiv 2016

  19. [19]

    Anil Koyuncu, Kui Liu, Tegawendé F Bissyandé, Dongsun Kim, Jacques Klein, Martin Monperrus, and Yves Le Traon

  20. [20]

    FixMiner: Mining relevant fix patterns for automated program repair.Empirical Software Engineering25, 3 (2020), 1980–2024

    2020

  21. [21]

    Xuan-Bach D Le, Lingfeng Bao, David Lo, Xin Xia, Shanping Li, and Corina Pasareanu. 2019. On reliability of patch correctness assessment. InProceedings of the 41st IEEE/ACM International Conference on Software Engineering. 524–535

    2019

  22. [22]

    Xuan-Bach D Le, Duc-Hiep Chu, David Lo, Claire Le Goues, and Willem Visser. 2017. S3: Syntax-and Semantic- guided Repair Synthesis Via Programming by Examples. InProceedings of the 11th Joint Meeting on European Software Engineering Conference and ACM SIGSOFT Symposium on Foundations of Software Engineering. 593–604

    2017

  23. [23]

    Xuan Bach D Le, David Lo, and Claire Le Goues. 2016. History Driven Program Repair. InProceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering, Vol. 1. IEEE, 213–224

    2016

  24. [24]

    Thanh Le-Cong, Duc-Minh Luong, Xuan Bach D Le, David Lo, Nhat-Hoa Tran, Bui Quang-Huy, and Quyet-Thang Huynh. 2023. Invalidator: Automated Patch Correctness Assessment Via Semantic and Syntactic Reasoning.IEEE Transactions on Software Engineering49, 06 (2023), 3411–3429

    2023

  25. [25]

    Claire Le Goues, ThanhVu Nguyen, Stephanie Forrest, and Westley Weimer. 2012. GenProg: A Generic Method for Automatic Software Repair.IEEE Transactions on Software Engineering38, 01 (2012), 54–72

    2012

  26. [26]

    Alexander LeClair, Sakib Haque, Lingfei Wu, and Collin McMillan. 2020. Improved code summarization via a graph neural network. InProceedings of the 28th International Conference on Program Comprehension. 184–195

    2020

  27. [27]

    Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. 2015. Gated graph sequence neural networks.arXiv preprint arXiv:1511.05493(2015)

    Pith/arXiv arXiv 2015

  28. [28]

    Yi Li, Shaohua Wang, and Tien N Nguyen. 2020. DLFix: Context-based Code Transformation Learning for Automated Program Repair. InProceedings of the 42nd ACM/IEEE International Conference on Software Engineering. 602–614

    2020

  29. [29]

    Yi Li, Shaohua Wang, and Tien N Nguyen. 2021. Vulnerability detection with fine-grained interpretations. InProceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 292–303

    2021

  30. [30]

    Yi Li, Shaohua Wang, and Tien N. Nguyen. 2022. DEAR: A Novel Deep Learning-based Approach for Automated Program Repair. InProceedings of the 44th International Conference on Software Engineering. 511–523. , Vol. 1, No. 1, Article . Publication date: April 2026. On the Effectiveness of Code Representation in Deep Learning-Based Automated Patch Correctness ...

    2022

  31. [31]

    Jingjing Liang, Ruyi Ji, Jiajun Jiang, Shurui Zhou, Yiling Lou, Yingfei Xiong, and Gang Huang. 2021. Interactive patch filtering as debugging aid. In2021 IEEE International Conference on Software Maintenance and Evolution. IEEE, 239–250

    2021

  32. [32]

    Bo Lin, Shangwen Wang, Ming Wen, and Xiaoguang Mao. 2022. Context-aware Code Change Embedding for Better Patch Correctness Assessment.ACM Transactions on Software Engineering and Methodology31, 3 (2022), 1–29

    2022

  33. [33]

    Kui Liu, Anil Koyuncu, Dongsun Kim, and Tegawendé F Bissyandé. 2019. Avatar: Fixing Semantic Bugs with Fix Patterns of Static Analysis Violations. InProceedings of the 26th IEEE International Conference on Software Analysis, Evolution and Reengineering. 1–12

    2019

  34. [34]

    Kui Liu, Anil Koyuncu, Dongsun Kim, and Tegawendé F Bissyandé. 2019. Tbar: Revisiting Template-based Automated Program Repair. InProceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis. 31–42

    2019

  35. [35]

    Kui Liu, Shangwen Wang, Anil Koyuncu, Kisub Kim, Tegawendé F Bissyandé, Dongsun Kim, Peng Wu, Jacques Klein, Xiaoguang Mao, and Yves Le Traon. 2020. On the Efficiency of Test Suite Based Program Repair: A Systematic Assessment of 16 Automated Repair Systems for Java Programs. InProceedings of the 42nd ACM/IEEE International Conference on Software Engineer...

    2020

  36. [36]

    Yiling Lou, Qihao Zhu, Jinhao Dong, Xia Li, Zeyu Sun, Dan Hao, Lu Zhang, and Lingming Zhang. 2021. Boosting Coverage-based Fault Localization Via Graph-based Representation Learning. InProceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 664–676

    2021

  37. [37]

    Thibaud Lutellier, Hung Viet Pham, Lawrence Pang, Yitong Li, Moshi Wei, and Lin Tan. 2020. Coconut: Combining Context-aware Neural Translation Models Using Ensemble for Program Repair. InProceedings of the 29th ACM SIGSOFT International Symposium on Software Testing and Analysis. 101–114

    2020

  38. [38]

    Fernanda Madeiral, Thomas Durieux, Victor Sobreira, and Marcelo Maia. 2018. Towards an automated approach for bug fix pattern detection.arXiv preprint arXiv:1807.11286(2018)

    Pith/arXiv arXiv 2018

  39. [39]

    Matias Martinez and Martin Monperrus. 2016. ASTOR: A Program Repair Library for Java. InProceedings of the 25th International Symposium on Software Testing and Analysis. 441–444

    2016

  40. [40]

    Matias Martinez and Martin Monperrus. 2018. Ultra-large Repair Search Space with Automatically Mined Templates: The Cardumen Mode of Astor. InProceedings of the International Symposium on Search Based Software Engineering. Springer, 65–86

    2018

  41. [41]

    Matias Martinez and Martin Monperrus. 2019. Coming: A tool for mining change pattern instances from git commits. In2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings. IEEE, 79–82

    2019

  42. [42]

    Sergey Mechtaev, Jooyong Yi, and Abhik Roychoudhury. 2016. Angelix: Scalable Multiline Program Patch Synthesis Via Symbolic Analysis. InProceedings of the 38th International Conference on Software Engineering. 691–701

    2016

  43. [43]

    Martin Monperrus. 2018. Automatic Software Repair: A Bibliography.Comput. Surveys51, 1 (2018), 1–24

    2018

  44. [44]

    Manish Motwani and Yuriy Brun. 2023. Better Automatic Program Repair by Using Bug Reports and Tests Together. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE Computer Society, 1225–1237

    2023

  45. [45]

    Manish Motwani, Mauricio Soto, Yuriy Brun, Rene Just, and Claire Le Goues. 2022. Quality of Automated Program Repair on Real-World Defects.IEEE Transactions on Software Engineering48, 02 (2022), 637–661

    2022

  46. [46]

    Lili Mou, Ge Li, Lu Zhang, Tao Wang, and Zhi Jin. 2016. Convolutional neural networks over tree structures for programming language processing. InThirtieth AAAI Conference on Artificial Intelligence

    2016

  47. [47]

    Marjane Namavar, Noor Nashid, and Ali Mesbah. 2022. A Controlled Experiment of Different Code Representations for Learning-based Program Repair.Empirical Software Engineering27, 7 (2022), 1–39

    2022

  48. [48]

    Zichao Qi, Fan Long, Sara Achour, and Martin Rinard. 2015. An Analysis of Patch Plausibility and Correctness for Generate-and-validate Patch Generation Systems. InProceedings of the 2015 International Symposium on Software Testing and Analysis. 24–36

    2015

  49. [49]

    André Silva, Sen Fang, and Martin Monperrus. 2024. RepairLLaMA: Efficient Representations and Fine-Tuned Adapters for Program Repair.arXiv preprint arXiv:2312.15698(2024)

    Pith/arXiv arXiv 2024

  50. [50]

    Jing Kai Siow, Shangqing Liu, Xiaofei Xie, Guozhu Meng, and Yang Liu. 2022. Learning program semantics with code representations: An empirical study. In2022 IEEE International Conference on Software Analysis, Evolution and Reengineering. IEEE, 554–565

    2022

  51. [51]

    Edward K Smith, Earl T Barr, Claire Le Goues, and Yuriy Brun. 2015. Is the Cure Worse Than the Disease? Overfitting in Automated Program Repair. InProceedings of the 10th Joint Meeting of the European Software Engineering Conference and ACM SIGSOFT Symposium on the Foundations of Software Engineering. 532–543

    2015

  52. [52]

    Victor Sobreira, Thomas Durieux, Fernanda Madeiral, Martin Monperrus, and Marcelo de Almeida Maia. 2018. Dissec- tion of a bug dataset: Anatomy of 395 patches from defects4j. In2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering. IEEE, 130–140

    2018

  53. [53]

    Weisong Sun, Chunrong Fang, Yun Miao, Yudu You, Mengzhe Yuan, Yuchen Chen, Quanjun Zhang, An Guo, Xiang Chen, Yang Liu, et al. 2026. Abstract Syntax Tree for Programming Language Understanding and Representation: How , Vol. 1, No. 1, Article . Publication date: April 2026. 26 Quanjun Zhang, Haichuan Hu, Chunrong Fang, Ye Shang, Tao Zheng, Zhenyu Chen, Yun...

    2026

  54. [54]

    Kai Sheng Tai, Richard Socher, and Christopher D Manning. 2015. Improved semantic representations from tree- structured long short-term memory networks.arXiv preprint arXiv:1503.00075(2015)

    Pith/arXiv arXiv 2015

  55. [55]

    Shin Hwei Tan, Hiroaki Yoshida, Mukul R Prasad, and Abhik Roychoudhury. 2016. Anti-patterns in Search-based Program Repair. InProceedings of the 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. 727–738

    2016

  56. [56]

    Yida Tao, Jindae Kim, Sunghun Kim, and Chang Xu. 2014. Automatically Generated Patches As Debugging Aids: A Human Study. InProceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. 64–74

    2014

  57. [57]

    Haoye Tian, Yinghua Li, Weiguo Pian, Abdoul Kader Kabore, Kui Liu, Andrew Habib, Jacques Klein, and Tegawendé F Bissyandé. 2022. Predicting Patch Correctness Based on the Similarity of Failing Test Cases.ACM Transactions on Software Engineering and Methodology31, 4 (2022), 1–30

    2022

  58. [58]

    Haoye Tian, Kui Liu, Abdoul Kader Kaboré, Anil Koyuncu, Li Li, Jacques Klein, and Tegawendé F Bissyandé. 2020. Evaluating Representation Learning of Code Changes for Predicting Patch Correctness in Program Repair. InProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. 981–992

    2020

  59. [59]

    Haoye Tian, Kui Liu, Yinghua Li, Abdoul Kader Kaboré, Anil Koyuncu, Andrew Habib, Li Li, Junhao Wen, Jacques Klein, and Tegawendé F Bissyandé. 2023. The Best of Both Worlds: Combining Learned Embeddings with Engineered Features for Accurate Prediction of Correct Patches.ACM Transactions on Software Engineering and Methodology32, 4 (2023), 1–34

    2023

  60. [60]

    Haoye Tian, Xunzhu Tang, Andrew Habib, Shangwen Wang, Kui Liu, Xin Xia, Jacques Klein, and Tegawendé F Bissyandé. 2022. Is This Change the Answer to That Problem? Correlating Descriptions of Bug and Code Changes for Evaluating Patch Correctness. In2022 37th IEEE/ACM International Conference on Automated Software Engineering

    2022

  61. [61]

    Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2019. An empirical study on learning bug-fixing patches in the wild via neural machine translation.ACM Transactions on Software Engineering and Methodology28, 4 (2019), 1–29

    2019

  62. [62]

    Ilya Utkin, Egor Spirin, Egor Bogomolov, and Timofey Bryksin. 2022. Evaluating the Impact of Source Code Parsers on ML4SE Models.arXiv preprint arXiv:2206.08713(2022)

    Pith/arXiv arXiv 2022

  63. [63]

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention Is All You Need. InAdvances in Neural Information Processing Systems. 5998–6008

    2017

  64. [64]

    Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. 2017. Graph attention networks.STAT1050 (2017), 20

    2017

  65. [65]

    Minjie Yu Wang. 2019. Deep graph library: Towards efficient and scalable deep learning on graphs. InICLR Workshop on Representation Learning on Graphs and Manifolds

    2019

  66. [66]

    Ruixin Wang, Zhongkai Zhao, Le Fang, Nan Jiang, Yiling Lou, Lin Tan, and Tianyi Zhang. 2025. Show Me Why It’s Correct: Saving 1/3 of Debugging Time in Program Repair with Interactive Runtime Comparison.Proceedings of the ACM on Programming Languages9, OOPSLA1 (2025), 1831–1857

    2025

  67. [67]

    Shangwen Wang, Ming Wen, Bo Lin, Hongjun Wu, Yihao Qin, Deqing Zou, Xiaoguang Mao, and Hai Jin. 2020. Automated Patch Correctness Assessment: How Far Are We?. InProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. 968–980

    2020

  68. [68]

    Cody Watson, Nathan Cooper, David Nader Palacio, Kevin Moran, and Denys Poshyvanyk. 2022. A systematic literature review on the use of deep learning in software engineering research.ACM Transactions on Software Engineering and Methodology31, 2 (2022), 1–58

    2022

  69. [69]

    W. E. Wong, R. Gao, Y. Li, R. Abreu, and F. Wotawa. 2016. A Survey on Software Fault Localization.IEEE Transactions on Software Engineering42, 8 (Aug. 2016), 707–740

    2016

  70. [70]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2025. Demystifying llm-based software engineer- ing agents.Proceedings of the ACM on Software Engineering2, FSE (2025), 801–824

    2025

  71. [71]

    Chunqiu Steven Xia and Lingming Zhang. 2022. Less Training, More Repairing Please: Revisiting Automated Program Repair Via Zero-shot Learning. InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 959–971

    2022

  72. [72]

    Qi Xin and Steven P Reiss. 2017. Identifying Test-suite-overfitted Patches through Test Case Generation. InProceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis. 226–236

    2017

  73. [73]

    Qi Xin and Steven P Reiss. 2017. Leveraging Syntax-related Code for Automated Program Repair. InProceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering. 660–670

    2017

  74. [74]

    Yingfei Xiong, Xinyuan Liu, Muhan Zeng, Lu Zhang, and Gang Huang. 2018. Identifying Patch Correctness in Test-based Program Repair. InProceedings of the 40th IEEE/ACM International Conference on Software Engineering. 789–799. , Vol. 1, No. 1, Article . Publication date: April 2026. On the Effectiveness of Code Representation in Deep Learning-Based Automat...

    2018

  75. [75]

    Yingfei Xiong, Jie Wang, Runfa Yan, Jiachen Zhang, Shi Han, Gang Huang, and Lu Zhang. 2017. Precise Condition Synthesis for Program Repair. InProceedings of the 39th IEEE/ACM International Conference on Software Engineering. IEEE, 416–426

    2017

  76. [76]

    Fabian Yamaguchi, Nico Golde, Daniel Arp, and Konrad Rieck. 2014. Modeling and discovering vulnerabilities with code property graphs. In2014 IEEE Symposium on Security and Privacy. IEEE, 590–604

    2014

  77. [77]

    Bo Yang and Jinqiu Yang. 2020. Exploring the Differences between Plausible and Correct Patches at Fine-grained Level. InProceedings of the 2nd IEEE International Workshop on Intelligent Bug Fixing. IEEE, 1–8

    2020

  78. [78]

    Jun Yang, Yuehan Wang, Yiling Lou, Ming Wen, and Lingming Zhang. 2023. A Large-Scale Empirical Review of Patch Correctness Checking Approaches. InProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 1203–1215

    2023

  79. [79]

    Yanming Yang, Xin Xia, David Lo, and John Grundy. 2022. A Survey on Deep Learning for Software Engineering. Comput. Surveys54, 10s (2022), 1–73

    2022

  80. [80]

    He Ye, Jian Gu, Matias Martinez, Thomas Durieux, and Martin Monperrus. 2022. Automated Classification of Overfitting Patches With Statically Extracted Code Features.IEEE Transactions on Software Engineering48, 8 (2022), 2920–2938

    2022

Showing first 80 references.