📊 statistics

Smooth Piecewise Cutting for Neural Operator to Handle Discontinuities and Sharp Transitions

This paper introduces Cut-DeepONet, a two-stage neural operator framework that explicitly models discontinuities by partitioning the domain into smooth subregions and predicting boundary locations, thereby achieving superior performance on PDEs with sharp transitions using fewer parameters and lower-resolution data compared to existing methods.

Original authors: Ha Dang, Sebastian Schmidt, Juergen Hesser

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ha Dang, Sebastian Schmidt, Juergen Hesser

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: Smooth Painters vs. Sharp Edges

Imagine you are teaching a robot artist (a Neural Operator) to paint pictures based on instructions. This robot is incredibly talented at painting smooth, flowing landscapes like rolling hills or calm oceans. It uses a special brush that naturally blends colors together.

However, the robot struggles when asked to paint something with a sharp, jagged edge, like a cliff dropping off a mountain or a sudden crack in a wall. Because the robot's brush is designed to blend, it tries to "smooth out" the sharp edge, turning a crisp cliff into a gentle, blurry slope. In the world of physics, these sharp edges are called discontinuities (like a shockwave in air or a sudden jump in temperature).

To fix this, previous attempts tried to make the robot's brain bigger or give it more data, hoping it would eventually learn to paint the sharp edge. But this is like trying to paint a razor-sharp line with a watercolor brush just by using more paint—it's inefficient and often still looks blurry.

The Solution: Cut-DeepONet (The "Cut and Paste" Strategy)

The authors propose a new method called Cut-DeepONet. Instead of forcing the robot to paint the sharp edge directly, they change the rules of the game. They split the painting task into two distinct steps, like a two-person assembly line.

Step 1: The "Cutting Net" (The Architect)

First, they train a small, specialized network called the Cutting Net. Think of this network as an architect or a scissor-wielding editor.

Its job: It looks at the instructions (the input data) and figures out exactly where the sharp edge or cliff should be.
The output: It doesn't paint the picture; it just draws a line on the blueprint saying, "Cut here." It identifies the location of the discontinuity.

Step 2: The "Lifted" Neural Operator (The Painter)

Once the architect has drawn the cut line, the main robot (the Neural Operator) gets to work. But here is the trick: the robot is no longer painting the whole messy picture at once.

The "Lifting" Trick: Imagine taking the paper, cutting it along the architect's line, and taping the two pieces onto a 3D wall so they don't touch.
The Result: Now, the robot only has to paint two separate, smooth pieces. It doesn't have to worry about the sharp edge anymore because the "edge" is now just the empty space between the two pieces on the wall.
The Magic: The robot paints these two smooth pieces perfectly. When you look at the final result, the two pieces are placed back together exactly where the architect told them to go. Because the robot didn't try to blend the colors across the gap, the final image has a perfectly sharp, true discontinuity.

Why This is a Game-Changer

The paper claims this approach offers three major benefits:

It's Smarter, Not Bigger: Instead of making the robot's brain huge to force it to learn sharp edges, they just change how the robot sees the problem. It's like realizing you don't need a stronger hammer to cut a diamond; you just need a diamond cutter.
It Works with Low-Resolution Data: Usually, to see a sharp edge, you need a very high-definition camera (high-resolution data). This method is so efficient that it can learn from blurry, low-quality photos and still produce a sharp result. It's like being able to draw a perfect straight line even if your reference photo is pixelated.
It Actually Creates Sharp Edges: Other methods try to approximate a sharp edge by making a very steep curve. Cut-DeepONet actually creates a true break in the data. It's the difference between a steep hill (approximation) and a sheer cliff (true discontinuity).

The Experiments: Putting It to the Test

The researchers tested this on three different "painting" challenges:

Linear Advection: Moving waves that suddenly stop or change direction.
Inviscid Burgers' Equation: A classic physics problem involving shockwaves (like a sonic boom).
A Heart Cell Model: A biological model where electrical signals jump suddenly (sharp transitions).

The Results:
In every test, Cut-DeepONet beat the current best methods (like DeepONet and FNO).

It made fewer mistakes overall.
It was especially good at the sharp edges, where other methods created "wobbly" or blurry lines.
It achieved this while using fewer parameters (less computing power) and training on lower-resolution data.

The Catch (Limitations)

The paper also admits a few things that need work:

The Architect Needs Good Blueprints: The "Cutting Net" needs to know where to cut. If the training data it learns from has the wrong cut locations (due to errors in the simulation), the final painting will be wrong.
Sampling Issues: In some complex cases, the sharp edge is so small that the robot might miss it during training, just like a painter might miss a tiny detail if they aren't looking closely enough.
Fixed Number of Cuts: Currently, the system is designed to handle a specific number of cuts. If a problem has a changing number of cracks or edges, the system might need to be updated.

Summary

In short, Cut-DeepONet solves the problem of teaching AI to handle sudden, sharp changes in physics by not trying to paint the sharp change at all. Instead, it uses a "Cutting Net" to find the break, and then teaches the main AI to paint the smooth pieces on either side. This results in a sharper, more accurate, and more efficient model.

Technical Summary: Cut-DeepONet for Handling Discontinuities in Neural Operators

Problem Statement

Neural operators, such as DeepONet and the Fourier Neural Operator (FNO), have demonstrated strong performance in learning solution operators for partial differential equations (PDEs). However, they face a fundamental limitation: their inherent architecture operates within smooth function spaces (e.g., Sobolev spaces), leading to an intrinsic smoothing bias. Consequently, these models struggle to accurately represent solutions containing discontinuities (e.g., shock waves) or sharp transitions.

Existing approaches attempt to mitigate this by increasing model capacity or utilizing high-resolution data to approximate discontinuities within continuous function spaces. However, this often results in Gibbs-like oscillations, requires excessive computational resources, and fails to capture the true nature of discontinuous solutions. Furthermore, in nonlinear PDEs, the location and number of discontinuities are often unknown a priori and emerge dynamically from the solution process, making fixed domain decomposition strategies (like XPINN) insufficient for general operator learning.

Methodology: Cut-DeepONet

The authors propose Cut-DeepONet, a two-stage training framework that explicitly models discontinuities by reformulating the problem rather than increasing model complexity. The core idea is inspired by "lifting" strategies used in neural fields, extended here to operator learning with input-dependent discontinuities.

1. Core Concept: Lifting and Domain Partitioning

Instead of forcing a neural network to approximate a discontinuous function directly, Cut-DeepONet lifts the problem into a higher-dimensional space.

Lifting Strategy: The domain is partitioned into smooth subregions separated by discontinuities. A discontinuity set $\Gamma(u)$ is mapped to an additional coordinate $H(\Gamma(u))$ .
Augmented Space: The output is represented in an augmented space $\tilde{y} = (y, H(\Gamma(u)))$ . In this lifted space, the solution components within each subdomain become continuous (smooth), while the discontinuities are relegated to the boundaries between regions.
Labeling: Unlike previous lifting methods that use winding numbers, this approach assigns distinct labels to each connected region $\Omega_j$ to handle sharp transitions where regions may exhibit entirely different behaviors.

2. Two-Stage Training Framework

The framework consists of two distinct stages:

Stage 1: Discontinuity Prediction (Cutting Net)

Goal: Predict the location of discontinuities $\Gamma(u)$ for unseen inputs.
Mechanism: A dedicated network, the Cutting Net ( $cnet_\theta$ ), is trained on a dataset of inputs paired with their corresponding discontinuity locations.
Data Preparation: Discontinuity locations are extracted from high-resolution ground truth solutions (or analytically derived where possible) by identifying peaks in the derivative field or using Rankine-Hugoniot conditions.

Stage 2: Operator Learning in Lifted Space

Goal: Learn the smooth solution components within each subdomain.
Mechanism: A neural operator ( $\hat{G}_\phi$ ) is trained on a "Lifted Dataset." The input is the original function $u$ , and the target is the solution in the augmented space $\tilde{G}(u)(\tilde{y})$ .
Advantage: Since the target function is continuous in the lifted space, the neural operator can learn the smooth pieces efficiently without needing to resolve steep gradients or discontinuities directly.

Prediction Phase
During inference, the trained Cutting Net predicts the discontinuity locations for a new input $u$ . These locations define the augmented coordinate $H(cnet_\theta(u))$ . The neural operator then generates the smooth solution components in the lifted space, which are mapped back to the original domain to reconstruct the final solution with true discontinuities at the predicted boundaries.

Key Contributions

Operator Learning in Smooth Space: The paper extends the lifting method from neural fields to operator learning, introducing a mechanism to generalize to unseen inputs with varying discontinuity structures.
True Discontinuity Generation: Unlike existing methods that approximate discontinuities via high-resolution continuous representations, Cut-DeepONet is the first to explicitly generate dynamic discontinuous solutions in operator learning.
Reduced Complexity: By decoupling the learning of discontinuity locations from the learning of smooth solution components, the method reduces the complexity of the operator learning task. It requires fewer trainable parameters and can achieve high accuracy even when trained on low-resolution datasets.
Performance on Discontinuous Tasks: The method demonstrates superior accuracy and faster convergence on problems involving shocks and sharp transitions compared to state-of-the-art baselines.

Experimental Results

The authors evaluated Cut-DeepONet on three benchmark problems:

Linear Advection Equation: A problem with two moving discontinuities.
Inviscid Burgers' Equation: A problem involving shock formation from a single initial discontinuity.
Parsimonious Model: A reduced Hodgkin–Huxley model for cardiomyocytes featuring sharp transitions in ion channel opening.

Findings:

Accuracy: Cut-DeepONet consistently outperformed DeepONet, FlexDeepONet, HyperDeepONet, and FNO in both global $L_1$ loss and localized discontinuity loss ( $L_{Dis}$ ) on the Linear Advection and Inviscid Burgers' equations.
Low-Resolution Training: The method maintained strong performance even when trained on significantly lower-resolution data, whereas baselines suffered from smoothing effects or oscillations.
Parameter Efficiency: Cut-DeepONet achieved these results with fewer trainable parameters than competing models.
Sharp Transitions: In the Parsimonious model, Cut-DeepONet achieved the lowest overall $L_1$ error. However, the localized discontinuity error was slightly higher than FNO in this specific case, which the authors attribute to the under-sampling of the small transition regions during random sampling training.

Significance and Claims

The paper claims that the primary bottleneck in learning discontinuous operators is not a lack of model capacity, but the mismatch between the smooth inductive bias of neural networks and the discontinuous nature of the target functions.

Representation Shift: The significance lies in changing the representation of the learning problem (lifting to a higher-dimensional space) rather than increasing model complexity.
Decoupling: By separating the task of "where" the discontinuity is (Cutting Net) from "what" the solution is (Neural Operator), the framework aligns the learning task with the strengths of neural networks (approximating smooth functions).
Generalization: The approach allows for the generation of true discontinuities in solutions for unseen inputs, a capability previously limited by the smoothing bias of standard neural operators.

The authors acknowledge limitations, noting that the Cutting Net relies on the accuracy of training data for discontinuity locations and that adaptive sampling strategies could further improve performance in regions with sharp transitions that occupy small portions of the domain. They also suggest future work could extend this lifting strategy to FNO architectures.