Pith. sign in

REVIEW 3 major objections 5 minor 64 references

Differentiating one fixed evaluator—not staging each candidate—makes parameter calibration fast enough that co-search can jointly explore program structure and continuous constants.

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 01:26 UTC pith:NZFWZ6OD

load-bearing objection Solid systems paper: locked cost model + real runtime that keeps programs as data and wins the low-reuse co-search regime; soft spots are mostly the regime limits the paper already states. the 3 major comments →

arxiv 2607.03574 v1 pith:NZFWZ6OD submitted 2026-07-03 cs.LG cs.AIcs.PL

Differentiate the Evaluator, Not the Program: An Efficient Runtime Representation for Neuro-Symbolic Learning

Lucas Sheneman This is my paper
classification cs.LG cs.AIcs.PL
keywords neuro-symbolic learningdifferentiable interpretersprogram-and-parameter co-searchreverse-mode autodiffruntime representationbatch amortizationscientific discovery
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.

AI systems can propose thousands of executable scientific models, but each candidate’s continuous parameters must be fitted before the model can be scored, so calibration becomes the bottleneck. Staging every program into its own differentiable graph is fast once compiled, yet it destroys the program-as-data property that keeps search fluid; ordinary interpreter-based differentiation keeps programs as data but spends most of its time boxing and walking values rather than doing arithmetic. This paper claims the cost is representational: in a locked profile of a real differentiable Scheme interpreter, value boxing and evaluator traversal account for 85–90% of forward time while arithmetic is about 1% or less, and the walk is essentially independent of batch size. NDVM separates discrete structure (tags, symbols, environments, control) from dense batched numeric payloads and records reverse-mode gradients only over the realized numeric trace, so one structural walk amortizes across large populations of parameter vectors. Realized as a native runtime with forward and gradient equivalence to the reference backend, it delivers about 60× per-lane batch amortization and, in fixed-budget co-search over language-model proposals, reaches high-quality solutions about 24× sooner in wall-clock time.

Core claim

For interpreter-level differentiation of programs kept as runtime data, the dominant bottleneck is representation and traversal, not floating-point work. A structural/numeric split with a payload-only reverse-mode tape lets one compiled evaluator walk serve a batch of parameter vectors with exact gradients along the realized trace, cutting per-lane calibration cost by about 60× and shifting fixed-budget co-search discovery about 24× earlier.

What carries the argument

Native Differentiable Virtual Machine (NDVM): a runtime representation that keeps tags, symbols, environments, and control as native scalar data while numbers live in dense batched primal/adjoint buffers, recording reverse-mode tape nodes only for numeric primitives on the exact realized execution path so one structural walk amortizes across a population.

Load-bearing premise

The co-search speedup assumes each structurally distinct candidate is fitted for only a handful of gradient steps and that population members largely share the same control path so one structural walk truly amortizes.

What would settle it

Replay a fixed stream of structurally distinct candidate programs under equal wall-clock budget on NDVM versus structure-cached staged compilation; if staging reaches the same held-out quality frontier first at reuse rates well below ~80 per skeleton or at per-candidate step counts far below the reported hundreds-to-tens-of-thousands crossover, the regime claim fails.

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

If this is right

  • Calibration stops being the co-search bottleneck; model proposal becomes the next limiting step under live generation.
  • Outer search can propose and discard thousands of structurally distinct programs without paying per-candidate staging.
  • Exact reverse-mode gradients remain available for arbitrary programs kept as data through one fixed evaluator.
  • Batch amortization plus near-linear multicore scaling make population fitting practical for control-heavy scientific models on CPU.
  • The same value-and-tape contract can be reused by independent front ends, not only one interpreter.

Where Pith is reading between the lines

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

  • Any neurosymbolic pipeline that currently boxes discrete tags and structure as tensors would likely inherit a similar representation-driven speedup without changing its language semantics.
  • Proposal strategies that keep candidate families on shared control skeletons would amplify the batch multiplier; heavy branch divergence would erode it toward per-lane cost.
  • Hybrid systems could run unstaged NDVM for short exploratory fits then stage only the winners once they survive many reuse steps, matching the paper’s own amortization crossovers.
  • A full GPU interpreter remains unmeasured; the paper’s own diagnosis that the walk is branchy and arithmetic-light implies CPU stays preferred until per-candidate numeric work dominates.

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 / 5 minor

Summary. The paper introduces the Native Differentiable Virtual Machine (NDVM), a runtime representation for interpreter-level differentiation that keeps programs as runtime data while making reverse-mode gradients cheap. Motivated by a locked Phase-0 cost model of a differentiable Scheme interpreter (DMCI on eager PyTorch) showing that value boxing and evaluator walking dominate (85–90% of forward time) while arithmetic is ≲1% and forward time is nearly batch-independent, NDVM splits structural values (tags, symbols, heap addresses, control) from dense batched numeric payloads and records a payload-only reverse-mode tape along the realized trace. The native CPU runtime is shown to match the baseline’s forward outputs and exact realized-trace gradients (including an 80-step Kalman matrix path), to amortize one structural walk across parameter populations (~60× native per-lane at B=256; ~21× through the PyTorch boundary), to scale near-linearly across cores, and to transfer the split to a second stack-bytecode client. In fixed-budget co-search over offline LLM-proposed programs, NDVM reaches high-quality held-out fits about 24× sooner (and ~340× on a recurrence-heavy task).

Significance. If the measurements hold, this is a useful systems contribution for program-and-parameter co-search and related neurosymbolic workloads: it identifies a concrete, reproducible bottleneck (representation, not FLOPs) and shows that a structural/numeric split plus one compiled evaluator can remove calibration as the inner-loop bottleneck without per-candidate staging. Strengths include the locked Phase-0 cost model, external baselines (tuned-eager, hand-written JAX, staged graphs, finite differences), randomized differential testing (600/600 and 1500/1500 checks), a clear amortization-regime analysis (Figures 6–7, structure-cached staging crossover), released code at a frozen tag, and an explicit “when NDVM is / is not the right tool” scope. The work is empirical systems research rather than a new AD theory; its value is the combination of program-as-data, exact-trace gradients, and batch amortization for short-lived candidates.

major comments (3)
  1. [Abstract; §6 (batch-native payloads)] Abstract and Contributions claim “about 60× per-lane batch amortization,” but §6 reports that the deployed figure through the cached PyTorch autograd.Function boundary is about 21× (0.63→0.029 ms), with 60× being the native runtime’s intrinsic number. For a load-bearing headline, the abstract and contribution list should lead with the deployed end-to-end figure (or state both with the boundary made explicit), so readers do not take 60× as the optimizer-facing speedup.
  2. [§7; Table 9; Table 11] Contribution 8 and §7 present a second front end as evidence of generality, but Table 11’s footnote states the stack-bytecode VM is a Python demonstration reusing the payload box via PyTorch autograd, not the native C++ runtime. The measured 1.8–3.3× split speedup and batch amortization therefore validate the representation idea under a different dispatch model, not native-runtime reuse. The generality claim should be restated at that strength (runtime-contract / value-box reuse), or the second client should be ported to the native runtime if a stronger claim is intended.
  3. [§7; Table 10; Figure 7] The end-to-end co-search results (§7, Figure 7) use offline-cached, compile-validated LLM proposal streams with the model outside the timed loop; live proposal cost is only estimated in the Amdahl table (Table 10). The 24× / 340× frontier shifts are real for calibration throughput under fixed candidate streams, but the paper’s framing toward “scientific discovery workflows” should more sharply separate measured offline co-search from unmeasured live LLM-in-the-loop discovery, especially since the paper itself shows proposal time becomes the floor once calibration is fast.
minor comments (5)
  1. [§3–4; Property 1] Property 1 is correctly labeled “intended semantics,” but a short forward pointer in §3–4 to the empirical validation protocol (oracle match + G1–G3 fuzzer) would help readers who expect a formal statement earlier.
  2. [Table 5] Table 5 notes that boxed C++ and residual-run NDVM times are not directly comparable because both re-parse; a one-sentence reminder in the table caption would prevent misreading the 1.5–1.8× split factor as the full residual of Table 4.
  3. [§6; Table 7; Table 11] The randomized fuzzer covers the scalar surface only; matrix/list/closure programs are conformance-tested. Stating this once in the abstract or contributions (not only in §6/Table 11) would set expectations for coverage.
  4. [Figure 2; Table 2] Figure 2’s caption says “four programs in the sweep” while the text mentions five programs overall; align the figure suite with Table 2 for consistency.
  5. [§1; §6] A few long sentences in the Introduction and §6 (especially the multi-clause speedup paragraphs) would benefit from splitting for readability without changing content.

Circularity Check

1 steps flagged

No significant circularity: empirical systems claims measured against external baselines; only mild non-load-bearing self-dependence on the author's prior DMCI client.

specific steps
  1. self citation load bearing [Abstract; §1 Introduction; §5 Phase-0; Contributions item 3–5]
    "A locked cost model of a real differentiable self-hosted Scheme interpreter motivates the design... We realize NDVM as a native runtime with forward and gradient equivalence to the reference backend... The motivating client is DMCI (Sheneman, 2026)"

    DMCI is the author's prior system and serves as both the profiled baseline and the gradient/forward oracle. That is self-dependence of the measurement stack, not a uniqueness theorem or a fitted quantity re-labeled as a prediction. It is not load-bearing for the central claim: equivalence is also checked by finite difference and a second non-DMCI bytecode client, and speedups are wall-clock ratios on fixed workloads, not consequences forced by the self-citation alone.

full rationale

This is an empirical systems paper whose load-bearing claims (locked Phase-0 cost model, forward/gradient equivalence, ~60× batch amortization, multicore scaling, ~24× co-search frontier shift, second bytecode-VM client) are measured wall-clock and numerical results, not first-principles derivations that reduce to their inputs by construction. Gradients are validated against an independent reverse-mode engine (PyTorch autograd) and central finite differences, and against hand-written JAX / staged-graph oracles that match to float32—none of which is a fitted parameter renamed as a prediction. The structural/numeric split and payload-only tape are design choices whose benefits are timed, not definitional identities. Mild self-dependence exists because DMCI (Sheneman 2026, same author) is both motivating client and frozen oracle, but the paper also reuses the value contract on a non-DMCI stack-bytecode VM, compares to external JAX/staging baselines, and reports crossovers where staging overtakes NDVM—so the central co-search claim is not forced by self-citation. Score 1 reflects that minor self-client dependence without elevating it to circularity of the result.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 2 invented entities

The central claims rest on a measured workload diagnosis plus design choices about language subset and search regime, not on fitted physical constants. Free parameters are experimental knobs (batch sizes, fit steps, budgets, tolerances). Axioms are standard reverse-mode AD plus domain assumptions about mutation-free programs and discrete exact-trace control. The main invented entity is the NDVM representation itself, which is implemented and tested rather than postulated as an unobserved physical object.

free parameters (4)
  • Batch size B for amortization headline = B=256 (also swept 1..1024)
    Per-lane ~60× claim is reported at B=256 (and deployed ~21× through the PyTorch boundary); B is an experimental operating point, not derived.
  • Co-search wall-clock budget and candidate streams = 900 s; 247 / 80 candidates
    End-to-end 24×/340× frontier shifts use fixed 900 s budgets and offline-cached LLM proposal streams (247 and 80 programs); stream composition and budget are experimental choices.
  • Inner Adam fit length for calibration throughput = 30 steps (crossovers n* ~213 to 4.2e4)
    Kalman calibration comparison uses a 30-step Adam fit; crossover n* depends on steps-per-candidate assumptions.
  • Differential-test float tolerances = atol/rtol as in Table 7 / REPRODUCE.md
    Correctness gates use chosen float32 tolerances (fwd 1e-4, grad 2e-3, FD 1e-2/5e-2), which define pass/fail of equivalence claims.
axioms (5)
  • standard math Reverse-mode AD over a realized numeric trace yields exact gradients of the composition of differentiable primitives on that trace (standard tape-over-trace AD).
    Used throughout Sections 3–4 and Appendix C; Property 1 states intended semantics without a machine-checked proof.
  • domain assumption Object language excludes mutation/aliasing; heap is write-once arena.
    Section 1 and 3.2; enables structural values without aliasing complications and bounds supported surface.
  • domain assumption Control remains discrete; gradients are exact only on the realized path and carry no information across branch flips.
    Section 4 Property 1; contrasts with soft/differentiable control in TerpreT-style interpreters.
  • domain assumption Target co-search evaluates many structurally distinct programs for few gradient steps each, with interpreter overhead dominating arithmetic.
    Section 1 'When NDVM is the right tool' and Phase-0 cost model; if false, staging or accelerators win.
  • ad hoc to paper Baseline DMCI/PyTorch measurements are representative of tensorized interpreter-level differentiation cost structure.
    Phase-0 diagnosis (Section 5) is locked to one client/backend/platform; generality beyond that is argued via a second small VM client.
invented entities (2)
  • Native Differentiable Virtual Machine (NDVM) structural/numeric runtime representation independent evidence
    purpose: Keep programs as runtime data while amortizing one evaluator walk across batched numeric payloads with payload-only reverse-mode tape.
    Core contribution; implemented in native C++ with measured equivalence and speedups rather than postulated as an unobserved physical object.
  • Compile-target contract for front ends lowering to NDVM values/tape ops no independent evidence
    purpose: Claim reusability across evaluators (DMCI and stack-bytecode VM).
    Stated as interface/intended semantics (Section 3.6); only two clients measured, formal contract not proved.

pith-pipeline@v1.1.0-grok45 · 38531 in / 3834 out tokens · 33066 ms · 2026-07-12T01:26:58.779663+00:00 · methodology

0 comments
read the original abstract

AI systems increasingly propose executable scientific models whose value depends on both their symbolic structure and their fitted continuous parameters. This makes parameter calibration the bottleneck of program-and-parameter co-search: an outer loop can generate thousands of candidate programs, but each needs an inner gradient-based optimization before it can be assessed. Staging each candidate into its own differentiable graph makes individual models fast but sacrifices the program-as-data property that keeps search fluid; interpreter-based approaches preserve programs as runtime data but pay interpreter overhead that dominates the numerical work. We present the Native Differentiable Virtual Machine (NDVM), a runtime representation that differentiates executable programs without compiling each candidate into a separate graph. NDVM separates symbolic structure from differentiable numeric state: tags, symbols, environments, and control remain native runtime data, while numeric payloads live in dense batched buffers with exact reverse-mode gradients recorded along the realized execution trace, so one evaluator walk is amortized across large populations of parameter vectors. A locked cost model of a real differentiable self-hosted Scheme interpreter motivates the design. We realize NDVM as a native runtime with forward and gradient equivalence to the reference backend, about 60x per-lane batch amortization, near-linear multicore scaling, and two independent front ends. In fixed-budget co-search over LLM-proposed programs, NDVM reaches high-quality solutions about 24x sooner in wall-clock time, suggesting runtime differentiation as a practical systems foundation for scientific discovery workflows.

Figures

Figures reproduced from arXiv: 2607.03574 by Lucas Sheneman.

Figure 1
Figure 1. Figure 1: Structural/numeric split in NDVM. Runtime values are fixed-size native records [PITH_FULL_IMAGE:figures/full_fig_p006_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Forward runtime changes by only 1 to 4% across a 1024× increase in payload batch size. Here B is the number of parameter vectors, restarts, or cells evaluated simultaneously on the current eager backend; the median rise is +3.6% across scalar, transcendental, and recursive programs (+1.0% for the logistic-map loop). The additional cost is only the dense payload arithmetic; the multi-millisecond interpreter… view at source ↗
Figure 3
Figure 3. Figure 3: Forward runtime decomposition of the eager DMCI backend across five programs spanning a [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Strong scaling of NDVM candidate-level parallelism. Independent candidate evaluations (each a complete [PITH_FULL_IMAGE:figures/full_fig_p011_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Decomposed forward speedup over the tagged eager backend. Teal bars show the representation-only gain of [PITH_FULL_IMAGE:figures/full_fig_p012_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Amortization regime for unstaged NDVM versus per-program staging. Total per-candidate wall-clock time is [PITH_FULL_IMAGE:figures/full_fig_p014_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: End-to-end co-search frontier. A fixed offline stream of [PITH_FULL_IMAGE:figures/full_fig_p018_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

64 extracted references · 1 canonical work pages · 1 internal anchor

  1. [1]

    arXiv preprint arXiv:2605.22498 , year =

    Lucas Sheneman , title =. arXiv preprint arXiv:2605.22498 , year =

    Pith/arXiv arXiv

  2. [2]

    Gleckler , title =

    Alex Shinn and John Cowan and Arthur A. Gleckler , title =. 2013 , howpublished =

    2013

  3. [3]

    Communications of the ACM , volume =

    John McCarthy , title =. Communications of the ACM , volume =. 1960 , doi =

    1960

  4. [4]

    1996 , address =

    Harold Abelson and Gerald Jay Sussman and Julie Sussman , title =. 1996 , address =

    1996

  5. [5]

    Gaunt and Marc Brockschmidt and Rishabh Singh and Nate Kushman and Pushmeet Kohli and Jonathan Taylor and Daniel Tarlow , title =

    Alexander L. Gaunt and Marc Brockschmidt and Rishabh Singh and Nate Kushman and Pushmeet Kohli and Jonathan Taylor and Daniel Tarlow , title =. arXiv preprint arXiv:1608.04428 , year =

    Pith/arXiv arXiv

  6. [6]

    Programming with a Differentiable

    Matko Bo. Programming with a Differentiable. Proceedings of the 34th International Conference on Machine Learning (. 2017 , publisher =

    2017

  7. [7]

    Differentiable Functional Program Interpreters

    John K. Feser and Marc Brockschmidt and Alexander L. Gaunt and Daniel Tarlow , title =. arXiv preprint arXiv:1611.01988 , year =. doi:10.48550/arXiv.1611.01988 , url =

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.1611.01988

  8. [8]

    Shah and Will Tebbutt , title =

    Mike Innes and Alan Edelman and Keno Fischer and Chris Rackauckas and Elliot Saba and Viral B. Shah and Will Tebbutt , title =. arXiv preprint arXiv:1907.07587 , year =

    Pith/arXiv arXiv 1907

  9. [9]

    2018 , howpublished =

    James Bradbury and Roy Frostig and Peter Hawkins and Matthew James Johnson and Yash Katariya and Chris Leary and Dougal Maclaurin and George Necula and Adam Paszke and Jake Vander. 2018 , howpublished =

    2018

  10. [10]

    Pearlmutter and Jeffrey Mark Siskind , title =

    Barak A. Pearlmutter and Jeffrey Mark Siskind , title =. ACM Transactions on Programming Languages and Systems (TOPLAS) , volume =. 2008 , doi =

    2008

  11. [11]

    Pearlmutter and Jeffrey Mark Siskind , title =

    Mehrdad Maleki and Barak A. Pearlmutter and Jeffrey Mark Siskind , title =. Scheme and Functional Programming Workshop (Scheme 2021), co-located with. 2021 , url =

    2021

  12. [12]

    Moses and Valentin Churavy and Ludger Paehler and Jan H\"

    William S. Moses and Valentin Churavy and Ludger Paehler and Jan H\". Reverse-mode automatic differentiation and optimization of. SC '21: Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , articleno =. 2021 , publisher =

    2021

  13. [13]

    Johnson and David Duvenaud and Dimitrios Vytiniotis and Alexey Radul and Matthew J

    Adam Paszke and Daniel D. Johnson and David Duvenaud and Dimitrios Vytiniotis and Alexey Radul and Matthew J. Johnson and Jonathan Ragan-Kelley and Dougal Maclaurin , title =. Proceedings of the. 2021 , doi =

    2021

  14. [14]

    Pearlmutter , title =

    Jeffrey Mark Siskind and Barak A. Pearlmutter , title =. Higher-Order and Symbolic Computation , volume =. 2008 , doi =

    2008

  15. [15]

    Gaunt and Marc Brockschmidt and Nate Kushman and Daniel Tarlow , title =

    Alexander L. Gaunt and Marc Brockschmidt and Nate Kushman and Daniel Tarlow , title =. Proceedings of the 34th International Conference on Machine Learning (. 2017 , publisher =

    2017

  16. [16]

    Macfarlane and Cl

    Matthew V. Macfarlane and Cl. Gradient-Based Program Synthesis with Neurally Interpreted Languages , booktitle =. 2026 , eprint =. doi:10.48550/arXiv.2604.18907 , url =

    Pith/arXiv arXiv doi:10.48550/arxiv.2604.18907 2026

  17. [17]

    5th International Conference on Learning Representations (

    Eric Jang and Shixiang Gu and Ben Poole , title =. 5th International Conference on Learning Representations (. 2017 , note =

    2017

  18. [18]

    Maddison and Andriy Mnih and Yee Whye Teh , title =

    Chris J. Maddison and Andriy Mnih and Yee Whye Teh , title =. 5th International Conference on Learning Representations (ICLR) , year =

  19. [19]

    arXiv preprint arXiv:1410.5401 , year =

    Alex Graves and Greg Wayne and Ivo Danihelka , title =. arXiv preprint arXiv:1410.5401 , year =. doi:10.48550/arXiv.1410.5401 , note =

    Pith/arXiv arXiv doi:10.48550/arxiv.1410.5401

  20. [20]

    ICLR , year=

    Scott Reed and Nando de Freitas , title=. ICLR , year=

  21. [21]

    4th International Conference on Learning Representations (

    Neural. 4th International Conference on Learning Representations (. 2016 , note =

    2016

  22. [22]

    Sun and Abhinav Verma and Yisong Yue and Swarat Chaudhuri , title =

    Ameesh Shah and Eric Zhan and Jennifer J. Sun and Abhinav Verma and Yisong Yue and Swarat Chaudhuri , title =. Advances in Neural Information Processing Systems 33 (. 2020 , url =

    2020

  23. [23]

    NeurIPS , pages =

    Robin Manhaeve and Sebastijan Dumancic and Angelika Kimmig and Thomas Demeester and Luc De Raedt , title =. NeurIPS , pages =

  24. [24]

    Proceedings of the ACM on Programming Languages , volume =

    Ziyang Li and Jiani Huang and Mayur Naik , title =. Proceedings of the ACM on Programming Languages , volume =. 2023 , doi =

    2023

  25. [25]

    Proceedings of the 42nd

    Kevin Ellis and Catherine Wong and Maxwell Nye and Mathias Sabl\'. Proceedings of the 42nd. 2021 , doi =

    2021

  26. [26]

    arXiv preprint arXiv:2305.01582 , year =

    Miles Cranmer , title =. arXiv preprint arXiv:2305.01582 , year =. doi:10.48550/arXiv.2305.01582 , url =

    Pith/arXiv arXiv doi:10.48550/arxiv.2305.01582

  27. [27]

    Science Advances , volume =

    Silviu-Marian Udrescu and Max Tegmark , title =. Science Advances , volume =. 2020 , doi =

    2020

  28. [28]

    Lew and Vikash K

    Mathieu Huot and Alexander K. Lew and Vikash K. Mansinghka and Sam Staton , title =. 2023 38th Annual. 2023 , publisher =. doi:10.1109/LICS56636.2023.10175739 , note =

    doi:10.1109/lics56636.2023.10175739 2023

  29. [29]

    Proceedings of the ACM on Programming Languages , volume =

    Conal Elliott , title =. Proceedings of the ACM on Programming Languages , volume =. 2018 , doi =

    2018

  30. [30]

    Decker and Xilun Wu and Gr\'

    Fei Wang and Daniel Zheng and James M. Decker and Xilun Wu and Gr\'. Demystifying Differentiable Programming: Shift/Reset the Penultimate Backpropagator , journal =. 2019 , doi =

    2019

  31. [31]

    A Simple Differentiable Programming Language , journal =

    Mart\'. A Simple Differentiable Programming Language , journal =. 2020 , publisher =

    2020

  32. [32]

    Proceedings of the

    Benjamin Sherman and Jesse Michel and Michael Carbin , title =. Proceedings of the. 2021 , doi =

    2021

  33. [33]

    Proceedings of the 31st

    Swarat Chaudhuri and Armando Solar-Lezama , title =. Proceedings of the 31st. 2010 , publisher =

    2010

  34. [34]

    Kreikemeyer and Philipp Andelfinger , title =

    Justin N. Kreikemeyer and Philipp Andelfinger , title =. IEEE Access , volume =. 2023 , doi =

    2023

  35. [35]

    Tracr: Compiled Transformers as a Laboratory for Interpretability , booktitle =

    David Lindner and J. Tracr: Compiled Transformers as a Laboratory for Interpretability , booktitle =. 2023 , doi =

    2023

  36. [36]

    Chris Lattner and Mehdi Amini and Uday Bondhugula and Albert Cohen and Andy Davis and Jacques Pienaar and River Riddle and Tatiana Shpeisman and Nicolas Vasilache and Oleksandr Zinenko , title =. 2021. 2021 , publisher =

    2021

  37. [37]

    The Optimal Growth of Tropical Sea Surface Temperature Anomalies , journal =

    Penland, C. The Optimal Growth of Tropical Sea Surface Temperature Anomalies , journal =. 1995 , doi =

    1995

  38. [38]

    A Stochastic Model of

    Penland, C. A Stochastic Model of. Physica D: Nonlinear Phenomena , volume =. 1996 , doi =

    1996

  39. [39]

    arXiv preprint arXiv:2506.13131 , year =

    Alexander Novikov and Ng. arXiv preprint arXiv:2506.13131 , year =

    Pith/arXiv arXiv

  40. [40]

    Pawan Kumar and Emilien Dupont and Francisco J

    Bernardino Romera-Paredes and Mohammadamin Barekatain and Alexander Novikov and Matej Balog and M. Pawan Kumar and Emilien Dupont and Francisco J. R. Ruiz and Jordan S. Ellenberg and Pengming Wang and Omar Fawzi and Pushmeet Kohli and Alhussein Fawzi , title =. Nature , volume =. 2024 , doi =

    2024

  41. [41]

    2025 , howpublished =

    Asankhaya Sharma , title =. 2025 , howpublished =

    2025

  42. [42]

    International Conference on Learning Representations (ICLR) , year =

    Hanxiao Liu and Karen Simonyan and Yiming Yang , title =. International Conference on Learning Representations (ICLR) , year =

  43. [43]

    Foundations and Trends in Programming Languages , volume =

    Swarat Chaudhuri and Kevin Ellis and Oleksandr Polozov and Rishabh Singh and Armando Solar-Lezama and Yisong Yue , title =. Foundations and Trends in Programming Languages , volume =. 2021 , doi =

    2021

  44. [44]

    Systems, Computers, Controls , volume =

    Partial Evaluation of Computation Process: An Approach to a Compiler-Compiler , author =. Systems, Computers, Controls , volume =

  45. [45]

    Partial Evaluation and Automatic Program Generation , author =

  46. [46]

    Advances in Neural Information Processing Systems 32 (NeurIPS 2019) , pages =

    Adam Paszke and Sam Gross and Francisco Massa and Adam Lerer and James Bradbury and Gregory Chanan and Trevor Killeen and Zeming Lin and Natalia Gimelshein and Luca Antiga and Alban Desmaison and Andreas K\". Advances in Neural Information Processing Systems 32 (NeurIPS 2019) , pages =

    2019

  47. [47]

    Practical partial evaluation for high-performance dynamic language runtimes , booktitle =

    Thomas W\". Practical partial evaluation for high-performance dynamic language runtimes , booktitle =. 2017 , publisher =

    2017

  48. [48]

    Thomas W\". One. Proceedings of the 2013. 2013 , publisher =

    2013

  49. [49]

    Tracing the meta-level:

    Carl Friedrich Bolz and Antonio Cuni and Maciej Fija. Tracing the meta-level:. Proceedings of the 4th Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems (. 2009 , publisher =

    2009

  50. [50]

    Laurent Hasco\". The. 2013 , doi =

    2013

  51. [51]

    Hogan , title =

    Robin J. Hogan , title =. 2014 , doi =

    2014

  52. [52]

    Hoffman and Marcus A

    Bob Carpenter and Matthew D. Hoffman and Marcus A. Brubaker and Daniel D. Lee and Peter Li and Michael Betancourt , title =. arXiv preprint arXiv:1509.07164 , year =

    Pith/arXiv arXiv

  53. [53]

    Bell , title =

    Bradley M. Bell , title =. 2024 , howpublished =

    2024

  54. [54]

    arXiv preprint arXiv:1810.07951 , year =

    Michael Innes , title =. arXiv preprint arXiv:1810.07951 , year =. doi:10.48550/arXiv.1810.07951 , note =

    Pith/arXiv arXiv doi:10.48550/arxiv.1810.07951

  55. [55]

    Proceedings of Machine Learning and Systems 3 (

    Brennan Saeta and Denys Shabalin and Marc Rasi and Brad Larson and Xihui Wu and Parker Schuh and Michelle Casbon and Daniel Zheng and Saleem Abdulrasool and Aleksandr Efremov and Dave Abrahams and Chris Lattner and Richard Wei , title =. Proceedings of Machine Learning and Systems 3 (. 2021 , note =

    2021

  56. [56]

    2016 , note =

    Dougal Maclaurin , title =. 2016 , note =

    2016

  57. [57]

    Wilson W. L. Fung and Ivan Sham and George Yuan and Tor M. Aamodt , title =. Proceedings of the 40th Annual. 2007 , publisher =

    2007

  58. [58]

    Hoffman and Rif A

    Alexey Radul and Brian Patton and Dougal Maclaurin and Matthew D. Hoffman and Rif A. Saurous , title =. Proceedings of Machine Learning and Systems 2 (. 2020 , note =

    2020

  59. [59]

    Machine Learning and Systems (

    Roy Frostig and Matthew James Johnson and Chris Leary , title =. Machine Learning and Systems (. 2018 , url =

    2018

  60. [60]

    1994 , doi =

    Goetz Graefe , title =. 1994 , doi =

    1994

  61. [61]

    Boncz and Marcin Zukowski and Niels Nes , title =

    Peter A. Boncz and Marcin Zukowski and Niels Nes , title =. Second Biennial Conference on Innovative Data Systems Research (. 2005 , url =

    2005

  62. [62]

    Boncz , title =

    Marcin Zukowski and Peter A. Boncz , title =

  63. [63]

    Chen and Martin Jankowiak and Fritz Obermeyer and Neeraj Pradhan and Theofanis Karaletsos and Rohit Singh and Paul Szerlip and Paul Horsfall and Noah D

    Eli Bingham and Jonathan P. Chen and Martin Jankowiak and Fritz Obermeyer and Neeraj Pradhan and Theofanis Karaletsos and Rohit Singh and Paul Szerlip and Paul Horsfall and Noah D. Goodman , title =. Journal of Machine Learning Research , volume =. 2019 , url =

    2019

  64. [64]

    Cusumano-Towner and Feras A

    Marco F. Cusumano-Towner and Feras A. Saad and Alexander K. Lew and Vikash K. Mansinghka , title =. Proceedings of the 40th. 2019 , doi =

    2019