A matrix-free, differentiable PyTorch solver for phase-field fracture: Formulation, benchmarks, and inverse analysis
summary
The gist
A matrix-free, open-source PyTorch solver is presented for phase-field fracture, designed to run on central processing units (CPUs) and graphics processing units (GPUs) without custom compiled…
In short
This paper introduces a matrix-free, open-source solver for phase-field fracture using PyTorch. It formulates mechanics as element-wise tensor operations to allow automatic differentiation, enabling easy integration with optimization and machine learning. The solver handles damage evolution via preconditioned conjugate gradient methods and is validated across various dynamic and quasi-static fracture benchmarks.
Key concepts
- Matrix-free approach
- Instead of building a large global stiffness matrix, this method calculates mechanics using only element-wise tensor contractions. This avoids the need for assembling massive sparse matrices, making the solver efficient on CPUs and GPUs.
- Automatic differentiation (Autograd) compatibility
- The explicit mechanics kernels are written using standard PyTorch primitives. This structure allows gradients to flow through the entire forward pass automatically, meaning users can easily train models or perform inverse problems without writing custom backpropagation code.
- Projected Preconditioned Conjugate Gradient (PPCG)
- This is a specific solver used to handle the damage evolution equation in the AT1 model. It enforces physical constraints, such as ensuring damage remains non-negative (d >= 0), by maintaining an active set of bound nodes during the solution process.
- Inverse Problem Capabilities
- The differentiable nature of the forward model is powerful for inverse problems. By using a single backward pass, the solver can efficiently compute gradients needed to recover unknown material properties from experimental data, even in high-dimensional scenarios.
Terminology used across episodes
This episode discusses
- A matrix-free, differentiable PyTorch solver for phase-field fracture: Formulation, benchmarks, and inverse analysis · Paper Radio
- DiffTaichi: Differentiable Programming for Physical Simulation
- Performance Portable Solid Mechanics via Matrix-Free p-Multigrid
- Training Deep Nets with Sublinear Memory Cost
The paper
A matrix-free, differentiable PyTorch solver for phase-field fracture: Formulation, benchmarks, and inverse analysis · Read on arXiv
Department of Engineering, City St George’s University of London · School of Engineering and Materials Science, Queen Mary University of London · Institute of Civil Engineering, École Polytechnique Férale de Lausanne (EPFL) · Department of Mechanical and Aerospace Engineering, University of Florida
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "A matrix-free, differentiable PyTorch solver for phase-field fracture".
Jane: Here's the gist of the paper. A matrix-free, open-source PyTorch solver is presented for phase-field fracture, designed to run on central processing units (CPUs) and graphics processing units (GPUs) without custom compiled extensions<ref:2606.23458#pg2> The explicit mechanics kernels are compatible with PyTorch’s automatic differentiation engine (autograd)<ref:2606.23458#pg8> This implementation is easier to extend or combine with differentiable optimisation and machine-learning components<ref:2606.23458#pg5> Solver Architecture The solver utilizes a matrix-free approach where finite-element operations are formulated as element-wise tensor contractions with scatter-based accumulation, removing global sparse mechanics-stiffness assembly from the core time-stepping loop<ref:2606.23458#pg2> The explicit forward pass is expressed using standard PyTorch tensor primitives, which allows gradients to flow through that path without handwritten backward kernels<ref:2606.23458#pg8> The solver operates by computing element-wise strain and stress using vectorised tensor operations<ref:2606.23458#pg2> Global assembly is performed by an indexed scatter accumulation, which is a differentiable primitive in PyTorch<ref:2606.23458#pg2> Damage Evolution and Constraints The phase-field equation is solved by a preconditioned conjugate gradient method at each subcycled time step<ref:2606.23458#pg2> For the AT1 model, the damage update involves a variational inequality which is enforced via a projected preconditioned conjugate-gradient (PPCG) solver<ref:2606.23458#pg2> The bound constraint d ≥ 0 is essential and is enforced via this method, which maintains an active set of bound-constrained nodes<ref:2606.23458#pg2> For the AT2 model, irreversibility can be enforced by simple clamping after the CG solve<ref:2606.23458#pg2> The solver optionally subcycles the damage sub-problem every Nsub-th step to ensure computational efficiency<ref:2606.23458#pg2> Inverse Problem Capabilities The primary advantage of a differentiable forward model is most evident in inverse problems, where the goal is to recover unknown material parameters or constitutive fields from observed data<ref:2606.23458#pg2> The solver supports this workflow because the main operations are written as PyTorch tensor operations<ref:2606.23458#pg8> A single backward pass computes the full gradient at a cost independent of the parameter dimension, making high-dimensional and field-valued inverse problems more tractable<ref:2606.23458#pg8> The demonstrated application is scalar material-parameter inversion for two different values of fracture toughness<ref:2606.23458#pg8> Benchmark Validation The solver is benchmarked against four dynamic fracture benchmarks (straight mode-I propagation, shear-induced kinking, dynamic branching, and crack-hole interaction) and two quasi-static benchmarks (Miehe SENT and the notched-holed plate)<ref:2606.23458#pg2> The validation results support the implementation across both dynamic and quasi-static settings<ref:2606.23458#pg2> For instance, in the Kalthoff–Winkler impact test, crack angles are reported to range between 67◦ to 73◦ across five meshes<ref:2606.23458#pg2> Performance and Comparison The performance scaling shows that the cost is consistent with near-linear scaling over the measured range, as expected for a matrix-free formulation in which the dominant element kernels are O(Ne)<ref:2606.23458#pg8> The damage CG solve accounts for approximately 59% of the step cost on smaller meshes (dominated by CG overhead) and decreases on larger meshes where the O(Ne) mechanics kernels take a larger share<ref:2606.23458#pg8> The solver is portable, running unmodified on macOS, Linux, and Windows, on both CPU and NVIDIA GPU backends<ref:2606.23458#pg2> The implementation is compatible with PyTorch’s native CUDA backend with no compiled extensions<ref:2606.
Paper summary: Tom: So looking at the whole picture of "A matrix-free, differentiable PyTorch solver for phase-field fracture: Formulation, benchmarks, and inverse analysis" it seems like the main point is that they’ve successfully created a way to solve complex phase field fracture problems using standard PyTorch tools without needing super specialized compilation or heavy sparse assembly <ref:2606.23458#pg1>.
Jane: The title itself tells you a lot. It covers the formulation for dynamic fracture, like AT1 and AT2 models, and it shows they tested it against various benchmarks, including dynamic branching and crack hole interaction <ref:2606.23458#pg2>.
Lu: What this means is that researchers can now tackle inverse problems more easily because that differentiable forward model lets you compute the full gradient at a cost independent of the parameter dimension <ref:2606.23458#pg3>. This makes recovering material properties from test data much more feasible than traditional methods like finite differencing or expensive Bayesian inference <ref:2606.23458#pg3>.
Meng: From a deployment standpoint, if you're worried about running it efficiently, they show that the cost scales near linearly with element kernels being O of n squared <ref:2606.23458#pg8>. And they acknowledge that the damage solve can take up fifty nine percent of the step cost on smaller meshes <ref:2606.23458#pg8>. That’s a realistic view for production environments where you need to know what to expect in terms of runtime <ref:2606.23458#pg8>.
Lalam: The paper focuses on showing that this formulation is robust across both dynamic and quasi static fracture settings, validating it against benchmarks like Miehe SENT and the Kalthoff Winkler impact test <ref:2606.23458#pg2>. This suggests the solver isn't just theoretical; it’s tested in real physical scenarios <ref:2606.23458#pg2>.
Jane: So to wrap up, this paper presents a matrix free approach that is easy to use with PyTorch for fracture simulations, which opens up new doors for testing material models and understanding how fracture toughness changes under different conditions <ref:2606.23458#pg2>.
Conclusion: Tom: So this paper presents a new way to solve phase field fracture problems using just PyTorch, without needing any custom compiled code or heavy sparse assembly.
Jane: It’s about making these complex simulations accessible on regular computers by using standard tensor operations, which is a big deal for getting things running quickly.
Lu: The authors focused on a matrix-free approach where they turn the mechanics into element-wise operations and use scatter accumulation to build the global assembly.
Meng: From an engineer’s view, that means we don't have to spend weeks writing custom kernels; we can just use what PyTorch already has, which is good for shipping models.
Lalam: The main thing they show is that this formulation works for both dynamic and quasi static fracture problems, which covers a lot of real-world testing scenarios.
Tom: So the big implication here is that it makes the whole workflow easier when you want to test how different material properties affect how a fracture behaves.
Jane: Exactly, because they made it differentiable, which means you can actually use this as a forward model in an inverse problem—you can work backward from observed data to find those unknown material parameters.
Lu: That’s the core research direction; by making the forward pass differentiable using standard PyTorch primitives, they enable learning about fracture toughness directly from experimental results.
Meng: I’m curious about the scaling though. How does this performance hold up when you try to scale it up to really big simulations where you have millions of elements?
Tom: The paper shows the cost scales near linearly with element kernels being O of n squared, which is what we expect from a matrix free formulation.
Jane: But they also note that the damage calculation part can take about fifty nine percent of the total step cost on smaller meshes, so you still have to watch your runtime budget there.
Lalam: So the paper confirms it’s a viable tool for researchers who want to combine physics simulation with machine learning optimization in a more unified way.
Tom: It’s about taking something that used to require super specialized coding and putting it into a framework everyone already uses, which is pretty exciting for the whole field.
Jane: So we’ve seen how they build the solver, what kind of problems they test it on, and how it handles those tricky damage constraints.
Lu: Now that you know how to run the simulation, the next step is figuring out what kinds of complex material behaviors this structure can actually handle when we start training AI models on fracture data.
More episodes
- 2505.16254-Human-AI Writing as Distributed Cognition: Reassessing Collaborative Writing Theories in the Age of LLMs
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game