A matrix-free, differentiable PyTorch solver for phase-field fracture: Formulation, benchmarks, and inverse analysis

arXiv:2606.23458 · cs.CE · Submitted 2026-06-22 · Read on arXiv

Listen

Radio episode about this paper

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.

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

cs.CE

Submitted: 2026-06-22

Updated: 2026-06-22

Comments: 31 pages, 23 figures

Code: https://github.com/CEMS-Lab/PhAST

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 99/100

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…

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

Summary

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. p. 023458#pg2> The explicit mechanics kernels are compatible with PyTorch’s automatic differentiation engine (autograd)<ref:2606. p. 023458#pg8> This implementation is easier to extend or combine with differentiable optimisation and machine-learning components<ref:2606. p. 023458#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. p. 123458#pg8> The solver operates by computing element-wise strain and stress using vectorised tensor operations<ref:2606. p. 223458#pg2> Global assembly is performed by an indexed scatter accumulation, which is a differentiable primitive in PyTorch<ref:2606. p. 223458#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. p. 523458#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. p. 523458#pg2> For the AT2 model, irreversibility can be enforced by simple clamping after the CG solve<ref:2606. p. 723458#pg2> The solver optionally subcycles the damage sub-problem every Nsub-th step to ensure computational efficiency<ref:2606. p. 823458#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. p. 223458#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. p. 223458#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. p. 023458#pg2> For instance, in the Kalthoff–Winkler impact test, crack angles are reported to range between 67◦ to 73◦ across five meshes<ref:2606. p. 123458#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. p. 323458#pg2> The implementation is compatible with PyTorch’s native CUDA backend with no compiled extensions<ref:2606. p. 3

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Matrix-free assembly of explicit dynamics allows for Local element-wise updates combined with a lumped mass matrix allow the mechanical update to be written in matrix-free form, avoiding global sparse assembly in the time-stepping loop. This enables efficient GPU execution and end-to-end simulation without custom compiled extensions or sparse matrices.

  2. Differentiability through the implicit solve avoids storing every conjugate gradient iteration by differentiating through the converged linear system instead of through the unrolled CG iterations, which keeps memory independent of the internal CG iteration count.

  3. The solver can perform scalar material parameter inversion by computing the gradient of L with respect to all active parameters using one backward sweep, providing a route to higher-dimensional inverse applications where finite-difference Jacobians also become expensive.

  4. The system supports coupling with neural network training loops because the implementation is built entirely on PyTorch tensor operations, allowing the solver and any downstream neural network to share a single autograd graph.

  5. The solver can handle complex fracture phenomena such as crack branching and crack-hole interaction by benchmarking against four dynamic fracture cases, including dynamic cracking and crack-hole interaction in perforated plates.

Sources

Related papers