Neural Operators: DeepONet and Fourier Neural Operators

Neural operators learn mappings between function spaces, so one trained model returns a whole equilibrium or field for a new profile, not a single point solution.

Learning operators, not functions

A PINN solves one PDE instance; a neural operator learns the solution operator itself - the map from input functions (profiles, boundary data, coil currents) to output functions (the full field). Once trained, it returns an entire breeder equilibrium or burner potential profile for a new input in one pass, ideal for scenario sweeps and the twin's fast path.

Operator learning target:

  G : a(x)  ->  u(x)      (input function -> solution function)

  DeepONet:  G(a)(y) = sum_k  b_k(a) * t_k(y)
     branch b_k : encodes input function a (sampled)
     trunk  t_k : encodes query location y

  Fourier Neural Operator (one layer):
     u <- sigma( W u + F^-1( R . F u ) )
     F : FFT ,  R : learned spectral weights (low modes)

DeepONet structure

A DeepONet factorizes the operator into a branch network that reads the input function and a trunk network that reads the query coordinate; their inner product gives the output at that point. This separation lets it evaluate the solution at any location and generalize across input functions drawn from the training distribution of breeder profiles.

Fourier neural operators

An FNO parameterizes the operator in the spectral domain: it transforms the field, multiplies low Fourier modes by learned weights, and transforms back. Because it acts on modes rather than a fixed grid, it is discretization-invariant - trainable at one resolution and evaluable at another - and efficient for the smooth, globally-coupled structure of equilibrium fields.

# FNO spectral convolution layer (schematic)
def fno_layer(u, R, W):
    u_hat = rfft(u)
    u_hat[:modes] = R @ u_hat[:modes]   # learned weights, low modes
    return relu(irfft(u_hat) + W @ u)   # spectral + local mixing

Role in the stack

Neural operators are the twin's reduced-order accelerators for whole-field predictions and the engine behind fast scenario sweeps. Like PINNs they are benchmarked against FEM and carry uncertainty; on the burner their outputs inherit the 166-830x regime caveat. They speed exploration; they do not replace the verified offline solvers or the honesty attached to burner physics.

• DeepONet: branch-trunk factorization, query at any location.
• FNO: spectral, discretization-invariant, efficient on smooth fields.
• Use: whole-field twin acceleration and scenario sweeps.
• Guardrail: FEM-benchmarked, uncertainty-reported, gates respected.

Operator learning is where the stack gets the most speed per model: one operator covers a family of solves the twin would otherwise iterate one by one.