pith. sign in

arxiv: 2606.26383 · v1 · pith:2CNMHRLPnew · submitted 2026-06-24 · 💻 cs.LG · cs.AI· cs.AR· cs.MA· cs.PF

SOLAR: AI-Powered Speed-of-Light Performance Analysis

Qijing Huang , Sana Damani , Zhifan Ye , Athinagoras Skiadopoulos , Siva Kumar Sastry Hari , Jason Clemons , Sahil Modi , Jingquan Wang
show 4 more authors
Aditya Kane Edward C Lin Humphrey Shi Christos Kozyrakis
This is my paper

Pith reviewed 2026-06-26 01:28 UTC · model grok-4.3

classification 💻 cs.LG cs.AIcs.ARcs.MAcs.PF
keywords speed-of-light analysisperformance boundsautomatic derivationdeep learning optimizationcode translationmulti-fidelity analysisanalytical modelingbound validation
0
0 comments X

The pith

A framework automatically derives validated speed-of-light performance bounds from deep learning source code.

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

The paper presents a method to automatically compute the theoretical minimum execution time of a workload on target hardware by processing its source code. An LLM component first converts the code into an executable intermediate representation that is checked for correctness through output matching, after which deterministic steps produce bounds at increasing levels of modeling detail. This addresses the prior need for manual, error-prone derivation that was disconnected from fast iteration in model development. If the approach holds, developers could obtain reliable headroom information and optimization clues directly during coding without separate analysis steps.

Core claim

SOLAR derives validated SOL bounds from source code by translating it via an LLM frontend into an executable Affine Loop IR validated by output comparison, lifting the IR into an einsum graph, and applying an analytical backend to compute unfused, fused, and cache-aware bounds, yielding zero observed violations and enabling multi-fidelity tightening that surfaces optimization insights.

What carries the argument

The LLM frontend that translates source programs into an executable Affine Loop IR validated by output comparison, which carries the argument by enabling the subsequent deterministic lifting and bound computation.

If this is right

  • Headroom analysis at multiple fidelity levels becomes available directly from code without manual derivation.
  • Optimization opportunities can be identified by observing how bounds tighten across fidelity levels.
  • Cross-platform exploration of performance limits is supported through the same automated flow.
  • Inverse-roofline hardware provisioning decisions can be informed by the computed bounds.

Where Pith is reading between the lines

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

  • Embedding the translation and bound steps into integrated development environments could provide immediate performance feedback while editing code.
  • The multi-fidelity tightening process might be reused for other quantitative limits such as memory usage or energy consumption.
  • If the translation component generalizes, similar automatic bound derivation could apply to workloads outside current deep learning code patterns.

Load-bearing premise

The LLM frontend reliably translates arbitrary source programs into an executable intermediate representation whose semantics are preserved for subsequent bound calculation and validation by output comparison.

What would settle it

A source program for which the generated bounds are violated by any actual execution or for which the translated representation produces output that differs from the original program.

Figures

Figures reproduced from arXiv: 2606.26383 by Aditya Kane, Athinagoras Skiadopoulos, Christos Kozyrakis, Edward C Lin, Humphrey Shi, Jason Clemons, Jingquan Wang, Qijing Huang, Sahil Modi, Sana Damani, Siva Kumar Sastry Hari, Zhifan Ye.

Figure 1
Figure 1. Figure 1: What SOLAR provides. SOLAR derives validated SOL bounds from source code, enabling three capabilities existing tools lack. (a) SOL headroom analysis: points below the diagonal reveal optimization opportunity; SOLAR exposes up to orders-of-magnitude headroom on KernelBench. (b) Tighter bounds: cache-aware analysis (OROJENESIS) accounts for on-chip buffer constraints, tightening SOL by up to 10× over naïve r… view at source ↗
Figure 2
Figure 2. Figure 2: End-to-end SOLAR example (LinearBiasMatmul). (a) PyTorch source. (b) Agent￾translated Affine Loop IR with named-dimension tensors and affine loops. (c) Einsum Graph (fusible edge dashed) with extracted einsum equations. (d) SOL analysis: fusion eliminates the intermediate, shifting the bottleneck from memory to compute. whose iterations carry no data dependence may be annotated Dim("B", parallel=True) by t… view at source ↗
Figure 3
Figure 3. Figure 3: SOL headroom analysis. (a) KernelBench: measured runtime over fused SOL across L1–L4 levels. (b) JAX/Flax: headroom (baseline / fused SOL) spans from 1.1× (BatchNorm) to 85.9× (MNISTCNN), demonstrating language-agnostic frontend coverage. 0 5 10 15 20 25 SOL Speedup (runtime / SOL) L1 L2 3.7x 5.1x 4.3x 21.6x 1.9x 10.5x Cache-aware fused SOL Unfused SOL Fused SOL (a) Multi-fidelity SOL speedup for L1/L2. Ca… view at source ↗
Figure 4
Figure 4. Figure 4: Optimization hints. (a) Multi-fidelity SOL on L1/L2: on L1, cache-aware is tightest (intra￾operator tiling costs dominate); on L2, unfused is tightest (intermediate tensor traffic dominates). (b) All 5 association orders of a 4-tensor MLA chain; 22× TFLOP range, with optimal order achieving 2.04× reduction over naïve left-to-right. 4.2 How Do I Design Efficient Algorithms for Target Hardware? SOLAR enables… view at source ↗
Figure 5
Figure 5. Figure 5: Qwen3-4B block parameter sensitivity on Jetson Thor. Fused and unfused SOL across four architectural axes. C/M = compute/memory-bound. Batch size drives linear scaling; sequence length triggers a memory→compute regime shift at ∼4K tokens. A6000 Jetson Thor H100 PCIe B200 Hardware Platform 10 0 10 1 SOL Runtime (ms) 3.6 2.1 0.7 0.6 Fused SOL Unfused SOL [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Cross-hardware Qwen3-4B block SOL. SO￾LAR enables designers to com￾pare deployment targets and identify the suited platform. pi0 GR00T N1.6 System 1 DreamZero WAM Model 0 10 20 30 40 50 60 70 80 SOL Runtime (ms) 2.0 ms 2.0 ms 2.0 ms 21.9 12.8 80.2 12.8 10.4 40.1 Unfused SOL Runtime Fused SOL Runtime (a) SOL runtime (unfused vs. fused). pi0 GR00T N1.6 System 1 DreamZero WAM Model 0.0 2.5 5.0 7.5 10.0 12.5 1… view at source ↗
Figure 8
Figure 8. Figure 8: KernelBench L1: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: KernelBench L2: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: KernelBench L3: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: KernelBench L4: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p013_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: SOL-EXECBENCH SOL analysis. (a) Each point is a workload; gap to the diagonal represents optimization headroom. (b) Quant kernels show the largest headroom (35.8×), followed by FlashInfer-Bench (18.8×), L1 (11.0×), and L2 (10.2×). C Robotics Model SOL Analysis [PITH_FULL_IMAGE:figures/full_fig_p013_12.png] view at source ↗
read the original abstract

How fast could a deep-learning model run on target hardware, and how far is today's implementation from that limit? These questions are central to software, hardware, and algorithm optimizations. Speed-of-Light (SOL) analysis answers them by computing a workload's theoretical minimum execution time on a given architecture. Yet deriving SOL bounds remains manual, error-prone, and disconnected from rapid model development. To close this gap, we introduce SOLAR, a framework that automatically derives validated SOL bounds from PyTorch and JAX source code. SOLAR leverages both generative and deterministic components in its flow: an LLM frontend translates any source programs into an executable Affine Loop IR, validated by output comparison; a deterministic flow lifts the IR into an einsum graph; and an analytical backend computes unfused, fused, and cache-aware SOL bounds. SOLAR provides comprehensive operator and language coverage, produces validated bounds with zero observed SOL violations, and offers multi-fidelity analysis that tightens bounds and surfaces optimization insights. We evaluate SOLAR across KernelBench, JAX/Flax models, and robotics workloads. These experiments demonstrate four use cases: headroom analysis at multiple fidelity levels, identifying optimization opportunities, cross-platform exploration, and inverse-roofline hardware provisioning.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 0 minor

Summary. The manuscript introduces SOLAR, a framework for automatically deriving Speed-of-Light (SOL) performance bounds from PyTorch and JAX source code. It uses a generative LLM frontend to translate programs into an executable Affine Loop IR (validated via output comparison), followed by deterministic lifting to an einsum graph and an analytical backend that computes unfused, fused, and cache-aware SOL bounds. The work claims comprehensive operator/language coverage, zero observed SOL violations across evaluations on KernelBench, JAX/Flax models, and robotics workloads, and demonstrates four use cases: multi-fidelity headroom analysis, optimization opportunity identification, cross-platform exploration, and inverse-roofline hardware provisioning.

Significance. If the central claim holds, SOLAR would meaningfully advance the field by automating a process that is currently manual and disconnected from rapid model iteration, enabling routine integration of theoretical performance limits into ML development. The hybrid generative-deterministic architecture and explicit multi-fidelity tightening of bounds are practical strengths that could surface actionable optimization insights and support hardware-software co-design. The deterministic analytical backend and emphasis on validation are positive elements that, if substantiated, would strengthen reproducibility in performance analysis.

major comments (2)
  1. [Abstract] Abstract (validation description): The central claim of 'validated bounds with zero observed SOL violations' rests on output comparison for the LLM frontend, but this only establishes functional equivalence on sampled inputs and does not verify preservation of loop nests, data dependencies, or memory access patterns; any such mismatch would invalidate the subsequent analytical SOL bounds (unfused/fused/cache-aware) without necessarily triggering output mismatches.
  2. [Abstract] Abstract (LLM frontend): The weakest assumption—that the generative LLM produces an Affine Loop IR whose semantics exactly match the source for einsum-graph lifting and bound computation—is load-bearing, yet the manuscript provides no concrete error analysis, coverage metrics, or counterexample search beyond output comparison, leaving the reliability of the computed bounds unassessable from the given description.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the careful review and for identifying the critical distinction between functional equivalence and structural preservation in the LLM frontend validation. The points raised are substantive and directly affect the strength of our claims regarding validated SOL bounds. We respond to each major comment below and will revise the manuscript accordingly.

read point-by-point responses

  1. Referee: [Abstract] Abstract (validation description): The central claim of 'validated bounds with zero observed SOL violations' rests on output comparison for the LLM frontend, but this only establishes functional equivalence on sampled inputs and does not verify preservation of loop nests, data dependencies, or memory access patterns; any such mismatch would invalidate the subsequent analytical SOL bounds (unfused/fused/cache-aware) without necessarily triggering output mismatches.

    Authors: We agree that output comparison on sampled inputs only confirms functional equivalence and does not guarantee preservation of loop nests, data dependencies, or memory access patterns. Any structural mismatch could invalidate the analytical SOL bounds without producing output discrepancies. This is a genuine limitation of the current validation approach described in the abstract. In the revised manuscript we will (1) qualify the validation claim in the abstract, (2) add a dedicated validation subsection that includes structural IR checks (loop-nest comparison and dependency-graph matching) on representative workloads, and (3) report the results of these additional checks. We will also discuss the residual risk to bound accuracy. revision: yes

  2. Referee: [Abstract] Abstract (LLM frontend): The weakest assumption—that the generative LLM produces an Affine Loop IR whose semantics exactly match the source for einsum-graph lifting and bound computation—is load-bearing, yet the manuscript provides no concrete error analysis, coverage metrics, or counterexample search beyond output comparison, leaving the reliability of the computed bounds unassessable from the given description.

    Authors: The manuscript does rely on the assumption that LLM-generated Affine Loop IR preserves the semantics needed for correct einsum-graph lifting and bound computation. The current description provides only output comparison and does not include error analysis, coverage metrics, or systematic counterexample search, making reliability difficult to assess. We accept this critique. The revision will add quantitative translation success rates, categorized error analysis from manual inspection of failures, and results from targeted counterexample searches. These additions will allow readers to evaluate the reliability of the computed bounds. revision: yes

Circularity Check

0 steps flagged

No circularity: analytical bounds derived from code via deterministic pipeline

full rationale

The paper describes a pipeline in which an LLM translates source to Affine Loop IR (validated only by output comparison on samples), a deterministic lift produces an einsum graph, and an analytical backend computes unfused/fused/cache-aware SOL bounds directly from that graph. No equations, parameters, or results are shown to be fitted to the target bounds or defined in terms of the bounds themselves. No self-citation chain is invoked as load-bearing justification for uniqueness or ansatz choices. The central claim therefore reduces to standard program analysis followed by closed-form roofline-style arithmetic rather than any self-referential construction.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract-only review yields no explicit free parameters, axioms, or invented entities; the LLM translation step implicitly assumes semantic preservation without stated formal guarantees.

pith-pipeline@v0.9.1-grok · 5802 in / 1044 out tokens · 24064 ms · 2026-06-26T01:28:30.026229+00:00 · methodology

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

59 extracted references · 8 canonical work pages · 4 internal anchors

  1. [1]

    Chen, Tianqi and Moreau, Thierry and Jiang, Ziheng and Zheng, Lianmin and Yan, Eddie and Cowan, Meghan and Shen, Haichen and Wang, Leyuan and Hu, Yuwei and Ceze, Luis and Guestrin, Carlos and Krishnamurthy, Arvind , booktitle = OSDI, year =

  2. [2]

    Evaluating Large Language Models Trained on Code

    Evaluating Large Language Models Trained on Code , author =. arXiv preprint arXiv:2107.03374 , year =

    work page internal anchor Pith review Pith/arXiv arXiv

  3. [3]

    Andrews, Martin and Witteveen, Sam , journal =

  4. [4]

    and Ermon, Stefano and Rudra, Atri and R

    Dao, Tri and Fu, Daniel Y. and Ermon, Stefano and Rudra, Atri and R

  5. [5]

    arXiv preprint arXiv:2412.19437 , year =

    work page internal anchor Pith review Pith/arXiv arXiv

  6. [6]

    The Meaning of Relativity , pages =

    The General Theory of Relativity , author =. The Meaning of Relativity , pages =

  7. [7]

    Quantum , volume =

    Hyper-Optimized Tensor Network Contraction , author =. Quantum , volume =

  8. [8]

    2026 , url =

    Lin, Edward and Modi, Sahil and Hari, Siva Kumar Sastry and Huang, Qijing and Ye, Zhifan and Qin, Nestor and Zhou, Fengzhe and Zhang, Yuan and Wang, Jingquan and Damani, Sana and others , journal =. 2026 , url =

    2026

  9. [9]

    IEEE Computer Architecture Letters , volume =

    Cache-Aware Roofline Model: Upgrading the Loft , author =. IEEE Computer Architecture Letters , volume =

  10. [10]

    2025 , url =

    Standardized Measurement Methodology for Kernel Benchmarking , author =. 2025 , url =

    2025

  11. [11]

    Proceedings of the ACM on Programming Languages , volume =

    The Tensor Algebra Compiler , author =. Proceedings of the ACM on Programming Languages , volume =

  12. [12]

    Li, Raymond and Ben Allal, Loubna and Zi, Yangtian and Muennighoff, Niklas and Kocetkov, Denis and Mou, Chenghao and Marone, Marc and Akiki, Christopher and Li, Jia and Chim, Jenny and others , journal =

  13. [13]

    Transformers are

    Dao, Tri and Gu, Albert , booktitle = ICML, year =. Transformers are

  14. [14]

    Dissecting

    Mei, Xinxin and Chu, Xiaowen , journal =. Dissecting

  15. [15]

    Nemotron-H: A Family of Hybrid

  16. [16]

    and Pellauer, Michael and Emer, Joel S

    Odemuyiwa, Toluwanimi O. and Pellauer, Michael and Emer, Joel S. , journal =. The

  17. [17]

    Proceedings of the 51st Annual International Symposium on Computer Architecture (ISCA) , year =

    Mind the Gap: Attainable Data Movement and Operational Intensity Bounds for Tensor Algorithms , author =. Proceedings of the 51st Annual International Symposium on Computer Architecture (ISCA) , year =

  18. [18]

    Andrulis, Tanner and Gilbert, Michael , title =

  19. [19]

    KernelBench: Can LLMs Write Efficient GPU Kernels?

    Ouyang, Anne and Guo, Simon and Arora, Simran and Zhang, Alex L. and Hu, William and R. arXiv preprint arXiv:2502.10517 , year =

    work page internal anchor Pith review Pith/arXiv arXiv

  20. [20]

    and Mukkara, Anurag and Venkatesan, Rangharajan and Khailany, Brucek and Keckler, Stephen W

    Parashar, Angshuman and Raina, Priyanka and Shao, Yakun Sophia and Chen, Yu-Hsin and Ying, Victor A. and Mukkara, Anurag and Venkatesan, Rangharajan and Khailany, Brucek and Keckler, Stephen W. and Emer, Joel , booktitle = ISPASS, year =. Timeloop: A Systematic Approach to

  21. [21]

    Paleo: A Performance Model for Deep Neural Networks , author =

  22. [22]

    Reed, James and DeVito, Zachary and He, Horace and Ussery, Ansley and Ansel, Jason , booktitle = MLSys, year =

  23. [23]

    Peng, Bo and Alcaide, Eric and Anthony, Quentin and Albalak, Alon and Arcadinho, Samuel and Biderman, Stella and Cao, Huanqi and Cheng, Xin and Chung, Michael and others , booktitle =

  24. [24]

    and Gray, Johnnie , journal =

    Smith, Daniel G.A. and Gray, Johnnie , journal =. opt\_einsum -- A

  25. [25]

    Design of a High-Performance

    Springer, Paul and Bientinesi, Paolo , journal =. Design of a High-Performance

  26. [26]

    MAPL , year =

    Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations , author =. MAPL , year =

  27. [27]

    torchview: Visualize

  28. [28]

    Attention Is All You Need , author =

  29. [29]

    Benchmarking

    Wang, Yu Emma and Wei, Gu-Yeon and Brooks, David , journal =. Benchmarking

  30. [30]

    Communications of the ACM , volume =

    Roofline: An Insightful Visual Performance Model for Multicore Architectures , author =. Communications of the ACM , volume =

  31. [31]

    Xu, Bing and Chen, Terry and Zhou, Fengzhe and Chen, Tianqi and Jia, Yangqing and Grover, Vinod and Wu, Haicheng and Liu, Wei and Wittenbrink, Craig and Hwu, Wen-mei and Bringmann, Roger and Liu, Ming-Yu and Ceze, Luis and Lightstone, Michael and Shi, Humphrey , journal =

  32. [32]

    Hierarchical Roofline Analysis for

    Yang, Charlene and Kurth, Thorsten and Williams, Samuel , journal =. Hierarchical Roofline Analysis for

  33. [33]

    USENIX ATC , year =

    Habitat: A Runtime-Based Computational Performance Predictor for Deep Neural Network Training , author =. USENIX ATC , year =

  34. [34]

    Zhang, Li Lyna and Han, Shihao and Wei, Jianyu and Zheng, Ningxin and Cao, Ting and Yang, Yuqing and Liu, Yunxin , booktitle =. nn-

  35. [35]

    Zhu, Jiace and Chen, Wentao and Fan, Qi and Ren, Zhixing and Wu, Junying and Chai, Xing Zhe and Rungrueangwutthinon, Chotiwit and Ma, Yehan and Zou, An , journal =

  36. [36]

    Ding, Yuran and Chen, Xinwei and Zhang, Xiaofan and Zhou, Zongwei , journal =

  37. [37]

    Zaeed, Mohammad and Islam, Tanzima Z. and Ind. Opal: A Modular Framework for Optimizing Performance using Analytics and. arXiv preprint arXiv:2510.00932 , year =

    work page arXiv

  38. [38]

    arXiv preprint arXiv:2505.03988 , year =

    Can Large Language Models Predict Parallel Code Performance? , author =. arXiv preprint arXiv:2505.03988 , year =

    work page arXiv

  39. [39]

    Yuan, Zhihang and others , journal =

  40. [40]

    ptflops: Flops Counter for

    Sovrasov, Vladislav , howpublished =. ptflops: Flops Counter for

  41. [41]

    Dao, Tri , journal =

  42. [42]

    Ramanujam and P

    Uday Bondhugula and Albert Hartono and J. Ramanujam and P. Sadayappan , title =. 2008 , doi =

    2008

  43. [43]

    Tools and Algorithms for the Construction and Analysis of Systems (TACAS) , series =

    Amir Pnueli and Michael Siegel and Eli Singerman , title =. Tools and Algorithms for the Construction and Analysis of Systems (TACAS) , series =. 1998 , publisher =

    1998

  44. [44]

    Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP) , pages =

    Koen Claessen and John Hughes , title =. Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP) , pages =. 2000 , doi =

    2000

  45. [45]

    Competition-Level Code Generation with

    Yujia Li and David Choi and Junyoung Chung and Nate Kushman and Julian Schrittwieser and R\'. Competition-Level Code Generation with. Science , volume =. 2022 , doi =

    2022

  46. [46]

    Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines , booktitle = PLDI, pages =

    Jonathan Ragan-Kelley and Connelly Barnes and Andrew Adams and Sylvain Paris and Fr\'. Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines , booktitle = PLDI, pages =. 2013 , doi =

    2013

  47. [47]

    Noah Shinn and Federico Cassano and Ashwin Gopinath and Karthik Narasimhan and Shunyu Yao , title =

  48. [48]

    Necula , title =

    George C. Necula , title =. 2000 , doi =

    2000

  49. [49]

    Polyhedral Parallel Code Generation for

    Sven Verdoolaege and Juan Carlos Juega and Albert Cohen and Jos. Polyhedral Parallel Code Generation for. 2013 , doi =

    2013

  50. [50]

    Gonzalez and Ion Stoica , title =

    Lianmin Zheng and Chengfan Jia and Minmin Sun and Zhao Wu and Cody Hao Yu and Ameer Haj-Ali and Yida Wang and Jun Yang and Danyang Zhuo and Koushik Sen and Joseph E. Gonzalez and Ion Stoica , title =

  51. [51]

    Unsupervised Translation of Programming Languages , booktitle = NIPS, year =

    Baptiste Rozi. Unsupervised Translation of Programming Languages , booktitle = NIPS, year =

  52. [52]

    Teaching Large Language Models to Self-Debug , journal =

    Xinyun Chen and Maxwell Lin and Nathanael Sch. Teaching Large Language Models to Self-Debug , journal =

  53. [53]

    Lin, Edward and Modi, Sahil and Hari, Siva Kumar Sastry and Huang, Qijing and Ye, Zhifan and Qin, Nestor and Zhou, Fengzhe and Zhang, Yuan and Wang, Jingquan and Damani, Sana and others , journal =

  54. [54]

    arXiv preprint arXiv:2406.01698 , year =

    Abhimanyu Bambhaniya and Ritik Raj and Geonhwa Jeong and Souvik Kundu and Sudarshan Srinivasan and Suvinay Subramanian and Midhilesh Elavazhagan and Madhu Kumar and Tushar Krishna , title =. arXiv preprint arXiv:2406.01698 , year =

    work page arXiv

  55. [55]

    Jimenez and John Yang and Alexander Wettig and Shunyu Yao and Kexin Pei and Ofir Press and Karthik Narasimhan , journal =

    Carlos E. Jimenez and John Yang and Alexander Wettig and Shunyu Yao and Kexin Pei and Ofir Press and Karthik Narasimhan , journal =

  56. [56]

    Program Synthesis with Large Language Models

    Program Synthesis with Large Language Models , author =. arXiv preprint arXiv:2108.07732 , year =

    work page internal anchor Pith review Pith/arXiv arXiv

  57. [57]

    Naman Jain and King Han and Alex Gu and Wen-Ding Li and Fanjia Yan and Tianjun Zhang and Sida Wang and Armando Solar-Lezama and Koushik Sen and Ion Stoica , booktitle =

  58. [58]

    2020 , url =

    Tyler Yep , title =. 2020 , url =

    2020

  59. [59]

    arXiv preprint arXiv:2603.29010v1 , year =

    Hari, Siva Kumar Sastry and Balaji, Vignesh and Damani, Sana and Huang, Qijing and Kozyrakis, Christos , title =. arXiv preprint arXiv:2603.29010v1 , year =

    work page arXiv