28th EuroAD Workshop

8 Dec 2025, 13:30 → 10 Dec 2025, 13:20 Europe/Zurich

31/3-004 - IT Amphitheatre (CERN)

The EuroAD Workshop series is a long-running, informal meeting focused on automatic differentiation (AD) -- its theory, tools, and diverse applications in science, engineering, and machine learning. The 28th edition will be hosted at CERN, offering a unique setting for exchanging ideas, showcasing new developments, and fostering collaboration across disciplines on a number of topics:

• Theoretical developments in AD
• AD tools, libraries, and language features
• AD in Machine Learning
• Applications in scientific computing and optimization
• Open challenges
• Any other “cool AD stuff”

 

We look forward to welcoming both new and returning participants for stimulating discussions in the unique environment of CERN.

Monday 8 December

Logistics: Registration

1 Welcome

Speakers: David Lange (Princeton University (US)), Vassil Vasilev (Princeton University (US))

Keynotes

Convener: Vassil Vasilev (Princeton University (US))

2 Automatically Differentiating Parametric Discontinuities

I will talk about our recent works on automatic differentiation algorithms for differentiating low-dimensional integrals of discontinuous functions, which are common in computer graphics, vision, and machine learning applications. Our method makes minimal assumptions on the program structure and does not require specialized routines for discretizing the integrals. We achieve this by directly sampling the Dirac delta distributions that arise at the decision boundaries. We then apply a program transformation that converts discontinuous functions into piecewise constant ones, this program transformation enables an efficient boundary sampling through a segment sampling technique. We show several applications in computer graphics, and I will talk about potential applications outside of graphics.

Speaker: Prof. Tzu-Mao Li (UCSD)

3 Computing higher-order derivatives with AD

The computation of higher-order derivatives using algorithmic differentiation has been an active area of research for several decades. In recent years, this topic has gained renewed attention due to the growing success of physics-informed neural networks (PINNs), in which such derivatives must be efficiently propagated through corresponding networks.

In this talk, we discuss several methodological approaches for obtaining higher-order derivatives using techniques from algorithmic differentiation. We also highlight emerging research directions that arise from questions related to computational efficiency, numerical stability, and software implementation.

Speaker: Prof. Andrea Walther (Humboldt-Universität zu Berlin)

Logistics: Coffee & Networking

Contributed Talks: Theory & Foundations

Convener: Aaron Jomy (CERN)

4 Collapsing Taylor Mode Automatic Differentiation

Computing partial differential equation (PDE) operators via nested backpropagation is expensive, yet popular, and severely restricts their utility for scientific machine learning. Recent advances, like the forward Laplacian and randomizing Taylor mode automatic differentiation (AD), propose forward schemes to address this. We introduce an optimization technique for Taylor mode that "collapses" derivatives by rewriting the computational graph, and demonstrate how to apply it to general linear PDE operators, and randomized Taylor mode. The modifications simply require propagating a sum up the computational graph, which could --or should-- be done by a machine learning compiler, without exposing complexity to users. We implement our collapsing procedure and evaluate it on popular PDE operators, confirming it accelerates Taylor mode and outperforms nested backpropagation.

Speaker: Tim Siebert (Humboldt-Universität zu Berlin and Zuse Institute Berlin, Berlin, Germany)

5 Optimal Jacobian Accumulation is NP-hard

Resolving a long-standing open question, we show that that the core AD problem of accumulating a Jacobian matrix while minimizing multiplications is NP-complete. Complementing this, we show that the running time of a relatively straight-forward $O^*(2^n)$ algorithm is essentially best possible under the Exponential Time Hypothesis. We also establish NP-completeness for the 'scarcity' problem of obtaining a minimum-size matrix-free Jacobian representation.

Importantly, we formulate both problems graph-theoretically, using sequences of vertex eliminations in a directed acyclic graph. Our results are facilitated by several illustrative structural insights about sequences of vertex eliminations, which also lead to a novel SAT encoding for Jacobian accumulation. We conclude with a discussion of open problems related to parameterized algorithms, approximations, and problem variants allowing edge eliminations. In addition to sharing our results, we hope to instigate more collaboration between graph algorithms researchers and the AD community.

Speaker: Blair D. Sullivan

6 2-D Shock AD: Practical Difficulties and (Im-) Practical Solutions

Computer simulations of the solution to conservation laws are important for the analysis of fluid flows, which is in turn used in the design of aircraft and spacecraft. Perhaps the most famous of these conservation laws are the Navier-Stokes equations, which describe the flow of most real fluids. If one considers an inviscid fluid, the Navier-Stokes equations reduce to the Euler equations, which can be used to model flows with large Reynolds numbers (or very low viscosity).

Solutions to the Euler equations can, even if the initial conditions are smooth, develop discontinuities (shocks). Understanding and analyzing these shocks is critically important for the design of craft capable of supersonic travel. This talk will focus on the use of the use of Automatic Differentiation (AD) and the application of a calculus of variations for solutions to conservation laws developed by Bressan & Marson in 1995 to the solution to the 2D Euler equations. Starting from the 1-D theory, we will examine some of the most interesting difficulties in extending the new calculus to a 2-D conservation law, and detail the use of:

• A local pseudoinversion technique for computing the sensitivity of the shock position to initial conditions
• Computing generalized tangent vectors using the shock sensitivities from local pseudoinversion

However, the extension to 2 space dimensions doesn't come "for free". We will also discuss some of the difficulties with the Bressan calculus, using AD to accumulate derivatives of a time-stepping method, and combining a shock-capturing finite volume method with the Bressan calclus.

Speaker: Alexander Fleming (RWTH Aachen University)

7 The Abs-Normal Form and Beyond: Rethinking Piecewise Linear Models

The talk discusses the Abs-Normal Form as a structured representation of piecewise linear functions and examines its main advantages and limitations. This form provides a systematic way to capture piecewise linear behavior commonly encountered in Algorithmic Piecewise Differentiation. Alternative representations, including the ReLU Normal Form and the more general Piecewise Normal Form, are presented and compared. The discussion outlines conceptual connections between these forms and their potential to support future developments in algorithm design and analysis. The talk concludes with reflections on how these representations can be used more effectively and what directions may be important for advancing Algorithmic Piecewise Differentiation.

Speaker: Torsten Bosse (Institut für Informatik, FSU Jena)

8 A clamp-function with enhanced differentiability

While there are a few common variants to restrict a value to a range, such as a clamp function and a smoothstep, they commonly have regions with vanishing gradients outside the target range. This makes these methods non-optimal for differentiable programming. Thus, we have built a better “clamp” using periodic functions, chosen to be efficient to compute compared to similar alternatives. Furthermore, this extends differentiability towards the position of the boundaries.

Speaker: Cord Bleibaum (DLR, Institute of Future Fuels)

9 Smooth relaxation of discrete structural constructs

In this talk I will present my ongoing research in differentiable programming, specifically its application to scenarios with discontinuities induced by discrete structural constructs like conditional statements. If the parameters with respect to which we wish to differentiate appear in the predicate, then obtaining derivatives with respect to those parameters by propagating tangents or adjoints is hopeless. From the mathematical perspective this can be explained by showing that the conditional is equivalent to the heaviside function in the parameters of interest, from AD perspective this means that the computation carried out to decide which branch is to be taken never enters the computational graph rendering AD algorithms ignorant to the decision making.

This is problematic since often times the underlying computed object is differentiable (or weakly differentiable), and the inability to capture its derivatives is a pure artifact of the implementation. If we want to achieve a truly end-to-end differentiable systems this issue needs to be dealt with. A simple technique of smooth relaxation mentioned by [1, 2, 3] can be used to address this problem. However, we show that blindly smoothing does not result in meaningful gradients. Using the bisection method for scalar root finding as a case study we derive its relaxed formulation and perform an analysis of the resultant algorithm which helps reveal the criterion that needs to be fulfilled to achieve consistency with implicit differentiation and bring meaning to the calculated derivative.

We speculate that for algorithms that are harder to study the consistency criterion can be learned or calibrated.

Keywords:

• Differentiable programming and differentiable systems
• Implicit differentiation and implicit function theorem
• Algorithmic differentiation
• Analysis of algorithms

References

• [1] M. Blondel and V. Roulet - The Elements of Differentiable Programming
• [2] S. Christodoulou and U. Naumann - Differentiable Programming: Efficient Smoothing of Control-Flow-Induced Discontinuities
• [3] A. Graves - Neural Turing Machines

Speaker: Anton Kovalov (RWTH Aachen University)

Logistics: Social Dinner

Tuesday 9 December

Keynotes

Convener: Vassil Vasilev (Princeton University (US))

10 How Automatic Differentiation can help Particle Physics

Experimentation at high-energy particle colliders is a well-established research field with a clear methodology and plans for large-scale experiments in the future. Its software stack includes packages developed over decades, specialized in particle collision simulation, detector simulation, data aggregation, and statistical analysis. To ensure the software's scalability for future collider experiments, the community continues to explore novel computing approaches to maximise the use of computational resources. This talk will explain possible areas where Automatic Differentiation can help in this endeavor, giving an overview of the research efforts to make parts of the HEP software stack differentiable. Particular emphasis is placed on statistical inference, where differentiable likelihoods enable significantly faster parameter optimization. As an example of a success story, this talk will present how source-code transformation AD, powered by Clad, was used to accelerate RooFit, the primary framework for statistical inference in particle physics.

Speaker: Jonas Rembser (CERN)

11 Efficient Differentiable Simulation of Light

Rendering algorithms simulate light by evaluating high-dimensional integrals that convert 3D scene descriptions into realistic images. Differentiable rendering turns this around: given one or more input observations (photographs or other measurements), it searches for a physical scene model that explains how these images were formed. This view casts many imaging tasks as inverse problems and has important applications in vision, graphics, and the natural sciences.

Differentiable light transport raises several unique challenges. Visibility introduces countless step discontinuities in the underlying integrals, which lead to incorrect gradients. Traditional tape-based automatic differentiation quickly exhausts memory because of the large amount of intermediate state. Efficient simulation further requires compilation to GPU “megakernels” that drive hardware ray tracing units. Finally, to be useful for domain experts, these simulations must remain highly customizable.

In this talk, I will present my group’s work on addressing these challenges, including Dr.Jit, a just-in-time compiler for differentiable Monte Carlo simulations, the Mitsuba renderer, and the nanobind Python binding library.

Speaker: Prof. Wenzel Jakob (EPFL)

Logistics: Coffee & Networking

Contributed Talks: Tools & Infrastructure

12 qruise-toolset: differentiable quantum simulation toolbox

We introduce qruise-toolset, a differentiable quantum simulation toolbox with a Python interface and a Julia simulation backend. It is specifically tailored for simulating open quantum systems and solving quantum optimal control problems. The toolset allows the user to benefit from the performance that the Julia JIT compilation offers and still feel at home with the convenience that the Python programming language provides. Moreover, we lift the requirement of using automatic differentiation packages such as PyTorch, TensorFlow or JAX, which are mostly suited for deep neural network architectures. We bring the world of automatic differentiation in Julia to Python thanks to the Enzyme.jl package, through the LLVM intermediate representation of the quantum simulation problem. We have seen performance gains up to 50x for the function calls. The general simulation of large quantum systems with 15 qubits can be 2x faster than conventional quantum simulation packages such as QuTiP. More importantly, this unlocks powerful new workflows around data-driven learning of digital twins of complex quantum systems, thus closing the Sim2Real gap.

1. Moses, W. and Churavy, V., 2020. Instead of rewriting foreign code for machine learning, automatically synthesize fast gradients. Advances in neural information processing systems, 33, pp.12472-12485.
2. Moses, W.S., Churavy, V., Paehler, L., Hückelheim, J., Narayanan, S.H.K., Schanen, M. and Doerfert, J., 2021, November. Reverse-mode automatic differentiation and optimization of GPU kernels via Enzyme. In Proceedings of the international conference for high performance computing, networking, storage and analysis (pp. 1-16).
3. Lattner, C. and Adve, V., 2003. A compilation framework for lifelong program analysis and transformation. In CGO (Vol. 4, p. 75).

Speaker: Yousof Mardoukhi (Qruise GmbH)

13 Automatic differentiation with Stochastic Rounding in Julia

Stochastic rounding is a pivotal technique to perform scientific computation in reduced precision and is becoming available on modern hardware. This talk will briefly introduce stochastic rounding and demonstrate automatic differentiation on several case studies using a software implementation of stochastic rounding in Julia.

Speaker: Dr Valentin Churavy (University of Augsburg)

14 Differentiating Object-Oriented paradigms using Clad

Clad is a Clang plugin that enables automatic differentiation for C++ by transforming abstract syntax trees using LLVM's compiler infrastructure. A key design goal is generating readable, efficient derivatives that integrate seamlessly into existing codebases. This talk explores the challenges of extending Clad to support object-oriented programming, demonstrating our approach through examples such as constructors, methods, and non-copyable types. We discuss the analyses and optimization techniques—both implemented and in development—that maintain code readability and performance when handling OOP paradigms. Finally, we present examples of use cases that these enhancements enable.

Speaker: Petro Zarytskyi (Princeton University (US))

15 AD-enabled pythonOCC for CAD-based shape optimization

pythonOCC is an open-source library extension that provides Python bindings for the widely-used Open CASCADE Technology (OCCT) geometry modeling kernel. It significantly facilitates the use of the CAD kernel in the context of automated processes for multidisciplinary design analysis and optimization (MDAO). To support gradient-based shape optimization, pythonOCC was differentiated using the AD tool ADOL-C in forward mode of AD and coupled with the differentiated OCCT in previous work. The AD-enabled pythonOCC and OCCT are integrated as a CAD plugin into a Python-controlled framework for high-fidelity MDAO relying on the FlowSimulator HPC ecosystem and OpenMDAO. The CAD plugin provides a robust metadata-supported mesh-to-CAD link and the computation of the so-called CAD sensitivities (e.g., derivatives of surface nodes w.r.t. design parameters). To demonstrate this workflow, a gradient-based shape optimization is performed using an aerodynamic test-case of reduced complexity.

Speaker: Mladen Banovic (German Aerospace Center (DLR))

16 Cache optimization of tape data

In operator overloading algorithmic differentiation tools, data is recorded on the tape for the reverse mode. The order of the statements is defined by the program, and the AD tool has to make an educated guess on the best layout of the adjoints, e.g., identifiers for the values. Since they are called for every floating-point operation, the heuristics need to be quick. In this talk, we want to present some techniques for the post-processing of the tape data such that the cache efficiency for the reverse evaluation of the tape is improved. The results are presented on industrial-relevant software packages.

Speaker: Max Sagebaum (RPTU Kaiserslautern-Landau)

17 ADTAYL: Taylor Series, ODEs, and Lie Derivatives in MATLAB

We describe ADTAYL, a Matlab package in two parts. The first, adtayl, is a class whose objects are arrays that behave like native Matlab arrays, except that each array element is a one-variable Taylor series (TS) instead of a number.

A TS is really a polynomial, but we call it TS because arithmetic operations don't quite follow the rules for algebra of polynomials. There is a maximum order p, fixed for each object, and if an operation generates terms of order >p they are simply dropped.
E.g. if x = x(t) holds 1+t and has order p=2, then x.x holds 1+2t+t², but x.x.*x holds 1+3t+3t² because the t³ term has been discarded.

Operations are numeric, so this is AD arithmetic, not symbolic algebra. As on native arrays, they are elementwise on arrays. E.g. if x holds [1+t, 1-t] then exp(x) holds [1+t+t²/2+t³/6+..., 1-t+t²/2-t³/6+...] to the given order p and within roundoff error.
There is a comprehensive list of elementwise standard functions. There is limited linear algebra: TS matrix multiplication, solution of linear equations, and matrix inversion. Array indexing, slicing, concatenating, etc. behave as for native arrays.

The second part is odets, an ODE solver whose interface as far as possible matches Matlab's ODE suite, but which solves initial value problems by a Taylor series method. Subject to some restrictions you can code a problem y'=f(t,y), y(0)=y₀ for, say, ode45; and then switch to using odets just by changing the name of the solver.

Taylor methods are especially good at high accuracy. You can switch to solving in arbitrary precision, simply by giving the initial values in Matlab's variable precision format vpa. It is slow, but mainly owing to the slowness of vpa arithmetic, particularly array handling.

The algorithms used in the two parts, adtayl and odets, are largely distinct. But they collaborate, surprisingly elegantly, in the computation of high-order Lie derivatives of scalar and vector fields - which have important applications for instance in control theory.

Speaker: Dr Ned Nedialkov (McMaster University)

Logistics: Lunch

Contributed Talks: Applications in Science & Engineering

Convener: Petro Zarytskyi (Princeton University (US))

18 Algorithmic differentiation for plane-wave DFT: materials design, error control and learning model parameters

We present a differentiation framework for plane-wave density-functional theory (DFT) that combines the strengths of forward-mode algorithmic differentiation (AD) and density-functional perturbation theory (DFPT). In the resulting AD-DFPT framework derivatives of any DFT output quantity with respect to any input parameter (e.g. geometry, density functional or pseudopotential) can be computed accurately without deriving gradient expressions by hand. We implement AD-DFPT into the Density-Functional ToolKit (DFTK) using dual numbers of ForwardDiff.jl, and show its broad applicability. Amongst others we consider the inverse design of a semiconductor band gap, the learning of exchange-correlation functional parameters, or the propagation of DFT parameter uncertainties to relaxed structures. These examples demonstrate a number of promising research avenues opened by gradient-driven workflows in first-principles materials modeling

Speaker: Niklas Frederik Schmitz (EPFL)

19 Scalable Semi-Matrix-Free Preconditioning for Newton-Krylov Solvers: Application to a Two-Phase Flow Simulation

Simulating two-phase flow in porous media requires solving large nonlinear systems, commonly via Newton–Krylov methods such as GMRES. These methods rely on Jacobian–vector products, which can be efficiently computed using automatic differentiation (AD), avoiding explicit Jacobian assembly. However, the lack of an assembled Jacobian complicates preconditioner design.

This work presents a sparsity-aware preconditioning strategy that constructs a sparsified Jacobian approximation using AD and graph coloring. The method exploits Jacobian sparsity to achieve scalable and memory-efficient preconditioning without forming or storing the full Jacobian matrix.

Results show that solver performance improves as the preconditioner better approximates the Jacobian, though gains diminish at higher sparsity due to memory costs. Despite minor deviations in saturation, overall accuracy, particularly in pressure, is preserved. The study demonstrates that semi-matrix-free methods combined with AD-based sparse preconditioning substantially reduce memory requirements while maintaining convergence, enabling scalable two-phase flow simulations in large reservoir models.

Speaker: Mia Ohlrogge (Friedrich-Schiller-Universität Jena)

20 Differentiable particle simulation for detector optimization

Applying automatic differentiation (AD) to particle simulations such as Geant4 opens the possibility of addressing optimization tasks in high energy physics, such as guiding detector design and parameter fitting, with powerful gradient-based optimization methods. In this talk, we refine our previous work on differentiable simulation with Geant by incorporating multiple coulomb scattering into the physics engine of the simulation. The introduction of multiple scattering adds layers of complexity, posing significant challenges for computing reliable unbiased derivatives with reasonable variance. These findings help build towards realistic optimizations of detectors with complete electromagnetic physics in Geant4.

Speaker: Jeffrey Krupa (SLAC)

21 High-Order Differential Algebra with the Generalized Truncated Power Series Algebra (GTPSA) and Its Application in MAD-NG

The Generalized Truncated Power Series Algebra (GTPSA) is a high-order differential algebra framework that provides real and complex multivariate Taylor expansions with accuracy close to symbolic computation. It naturally supports automatic differentiation of abritrary order, with simultaneous propagation of mixed partial derivatives and functional composition, while maintaining high computational efficiency. GTPSA is among the fastest open-source libraries available for high-order differential algebraic computations.

In the field of accelerator physics, GTPSA forms the computational core of MAD-NG (Methodical Accelerator Design – Next Generation), a modern standalone framework for linear and nonlinear optics, as well as high-order beam dynamics analysis. Within MAD-NG, GTPSA enables direct computation of optical functions, linear and nonlinear lattice maps, and Lie algebraic operators with machine precision and full parametric dependency on user-defined expressions. Combined with the LuaJIT high-performance scripting engine and the C++ template-based parametric polymorphism, this architecture delivers exceptional computational throughput while preserving algebraic clarity and consistency.

This presentation will introduce the GTPSA formalism, its automatic differentiation mechanisms, and illustrate its application to advanced beam optics and nonlinear map analysis in MAD-NG, highlighting how high-order AD enables accurate and scalable modeling of modern accelerator systems.

Speaker: Dr Laurent Deniau (CERN)

Logistics: Coffee & Networking

Logistics: CERN Experimental Site Visit

Wednesday 10 December

Contributed Talks: Training & Education

Convener: Max Sagebaum (RPTU Kaiserslautern-Landau)

22 Reflections on developing a differentiable programming course

Every summer, the Institute of Computing for Climate Science (ICCS) hosts a summer school on software engineering and scientific computing for climate science. The target audience mainly includes students and scientists that we collaborate with on climate modelling projects and the aim is to provide them training on software engineering best practices and updates on current topics. Differentiable programming is currently a hot topic in the climate modelling domain, so we introduced a Differentiable Programming course for the first time in the 2025 summer school. The course ran over two 1.5-hour sessions and covered both forward and reverse mode, and both the source transformation and operator overloading approaches. In this talk, we will describe how we developed and delivered the course and reflect on what we could improve upon for the next iteration.

Speaker: Joe Wallwork (Institute of Computing for Climate Science, University of Cambridge, UK)

23 Teaching SIMD computing with a vector forward-mode AD tool

Teaching is not only an integral part of everyday academic life, but also a key opportunity for academic teaching staff to recruit young scientists.
To that end, illustrative assignments that allow students to actively engage with topics relevant to current research are especially valuable.

We present a classroom-tested assignment for undergraduate students in their sophomore year. In this assignment, students implement a basic operator overloading AD tool that utilizes SIMD instructions for vector forward-mode AD. This AD tool is then employed to solve an optimization problem using a basic gradient-descent algorithm.

Speaker: Johannes Schoder (Friedrich-Schiller-Universität Jena)

24 Creative Barkeeping or: How can AD be explained without jargon?

I have been teaching AD etc. (numerical methods, programming, compilers) to students at various levels of academic maturity (ranging from 1st year BSc to PhD) for a few years now. Many topics covered feature considerable overlap in terms of data structures (e.g., matrices, graphs) and algorithms (e.g., basic linear algebra, graph traversal / transformation) appearing at the very core of the stories told. Wouldn't is be nice if there was a corresponding cover story that can be digested by everybody, including 1st year BSc students?

There is such a story and I intent to present its ``executive summary''. In particular, this talk is meant to illustrate the links of the story with the corresponding topics in AD, including vector modes, compression and elimination techniques for Jacobian accumulation and checkpointing for data flow reversal in adjoint mode.

Speaker: Uwe Naumann (RWTH Aachen University)

25 Teaching Automatic Differentiation with Interactive C++ Jupyter Notebooks

The compiler research group pioneered interactive C++ notebooks with xeus-clang-repl, and its successor xeus-cpp. The ability to write automatic differentiation code in an interactive context eliminates the need for long edit-compile-run cycles and simplifies the approach to teaching computational methods.

By leveraging the clang-repl C/C++ interpreter, we create an interactive notebook environment for teaching autodiff concepts and evaluating the efficiency and correctness of differentiated code. This approach combines the performance of compiled C++ with the accessibility of Jupyter notebooks, making advanced automatic differentiation techniques more approachable for students and researchers.

This talk demonstrates how various C++ automatic differentiation tools, such as CoDiPack, Clad and boost-autodiff integrate with the xeus-cpp Jupyter kernel to enable interactive differentiable programming.

Speaker: Aaron Jomy (CERN)

Logistics: Coffee & Networking

Contributed Talks: Tools & Infrastructure

26 AD Mission Playground: An Interactive Tool for Elimination Techniques

Elimination techniques for computational graphs can substantially speed up the accumulation of Jacobian matrices. Low-level elimination techniques that operate on the level of elementary operations are already integrated in various AD tools and can automatically speed up derivative calculations for the user. High-level elimination techniques, like generalized face elimination, currently require more manual interaction and insight from the user to model the high-level DAG and execute the elimination sequence by calling the correct tangent and adjoint models.
To support the user, we developed a web application that allows them to model their DAG, automatically calculates the (near-)optimal elimination sequence, and provides a plan for implementing a possible driver for the elimination sequence. This tool also acts as a great teaching tool for lectures and tutorials.

Speaker: Mr Simon Märtens (RWTH Aachen University)

27 Bidirectional random number generators and applications in adjoint automatic differentiation

Bidirectional random number generators (RNGs) allow stochastic sequences to be reproduced not only forward but also backward in time. This capability can be leveraged in adjoint automatic differentiation (AD) to significantly reduce memory usage: instead of storing all intermediate random variates on the tape for backpropagation, the AD engine can efficiently regenerate them in reverse order at negligible computational cost. We demonstrate this idea in a representative computational-finance setting, showing how bidirectional RNGs enable lighter adjoint memory footprints while preserving the accuracy and performance of gradient calculations.

Speaker: Jean-Luc Rey (Bloomberg)

28 Efficient Derivative Computation for Accelerator Beam Optics Calculations

Designing optics for accelerators is a continuous process requiring the solution of many multi-dimensional optimization problems. Given the multitude of operating configurations that have to be considered, as well as the increasing size and complexity of modern accelerators, runtime becomes a limiting factor — in particular because computing the required derivatives accounts for most of the total runtime.
In this contribution, we compare two approaches for obtaining these derivatives. The first uses Automatic Differentiation with JAX applied to linear optics, which is highly efficient when a linear description is sufficiently accurate. The second relies on truncated power series algebra (TPSA) as implemented in MAD-NG, offering more precise derivatives and therefore allowing to capture higher-order physical effects. We evaluate their respective strengths and limitations and outline the situations in which each method provides the best balance between accuracy and performance.

Speaker: Bernardo Abreu Figueiredo (RWTH Aachen University)

29 Closing

Speaker: Vassil Vasilev (Princeton University (US))