Discontinuous Galerkin Neural Operator (DGNO)

• DGNO is a neural operator architecture that partitions the domain into localized elements and couples them via DG-style numerical fluxes to manage spatially varying blur.
• It decomposes the global operator into element-local volume terms and interface flux contributions, ensuring effective handling of discontinuities and heterogeneity.
• Architectural variants like DGNO-Face and DGNO-Cell demonstrate enhanced performance metrics (PSNR, SSIM) and scalability in pathology deblurring and related PDE tasks.

Searching arXiv for the cited DGNO and related DG-based neural methods to ground the article in current papers. Searching for "Discontinuous Galerkin Neural Operator pathology defocus deblurring" on arXiv. Discontinuous Galerkin Neural Operator (DGNO) denotes a neural-operator architecture that partitions a domain into elements, applies an element-local integral operator within each element, and couples adjacent elements through discontinuous Galerkin-style numerical fluxes on interfaces. In the explicit sense of the acronym, the term refers to a model introduced for pathology defocus deblurring, where defocus is treated as a spatially varying integral imaging process rather than a shift-invariant convolution (Duan et al., 22 May 2026). In a broader research context, the label also serves as a useful umbrella for DG-structured neural methods that combine broken local representations, weak inter-element coupling, and operator-level learning or residual minimization, including DG-FEONet, DGNN, DGPWNN, and related DG-neural hybrids for non-smooth PDEs and wave problems (Chawla et al., 7 Jan 2026).

1. Definition and conceptual scope

In its explicit formulation, DGNO was proposed for pathology defocus deblurring, motivated by the claim that microscopic defocus is fundamentally a spatially varying and locally discontinuous blur process induced by a position-dependent integral operator (Duan et al., 22 May 2026). The forward imaging model is written as

$$g(x, y) = \int K(x, y;\xi, \eta) h(\xi, \eta)\, d\xi d\eta,$$

where $h$ is the latent sharp image, $g$ is the observed blurred image, and $K(x,y;\xi,\eta)$ is the spatially varying point spread function. Only when $K$ depends on relative coordinates alone does this reduce to convolution. The method therefore positions deblurring as operator inversion rather than finite-dimensional regression (Duan et al., 22 May 2026).

The neural-operator starting point is the standard function-to-function map

$u(\cdot)=G(a(\cdot)),$

with pointwise lifting and projection,

$z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$

and operator layers

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$

where the nonlocal term is

$(K z)(x)=\int_D k_{\phi}(x,y) z(y)\,dy.$

DGNO modifies this global integral operator by replacing a single globally parameterized kernel with an elementwise DG decomposition (Duan et al., 22 May 2026).

A broader editorial reading is supported by several later papers that do not always use the acronym DGNO but implement its central ingredients: discontinuous local approximation spaces, weak interface coupling, and learning in DG coefficient or trial spaces. DG-FEONet predicts coefficients in a broken polynomial basis and minimizes the residual of a SIPG weak form for parametric PDEs with discontinuous coefficients (Chawla et al., 7 Jan 2026). DGNN replaces piecewise polynomial trial spaces by element-wise neural networks and enforces a DG-style least-squares residual with interface terms (Yuan et al., 9 Nov 2025). DGPWNN uses element-wise plane-wave neural functions inside a DG/Trefftz least-squares formulation for Helmholtz and Maxwell problems (Yuan et al., 11 Jun 2025). This suggests that “DGNO” can designate both a specific pathology-deblurring architecture and a wider class of DG-structured neural operators or operator-like solvers.

2. Operator formulation and DG decomposition

The defining DGNO layer is

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K^{DG} z_t)(x)\right), \quad x\in D,$$

with the spatial domain partitioned as

$h$0

The global operator is assembled elementwise,

$h$1

and decomposed into a local volume term plus interface flux terms,

$h$2

This is the central structural equation of DGNO (Duan et al., 22 May 2026).

The element-local volume operator is

$h$3

so information is aggregated only from points within the same element. The interface contribution is

$h$4

where $h$5 and $h$6 are traces from the two neighboring elements and $h$7 is a numerical flux. The construction is therefore explicitly discontinuous: each element maintains its own operator representation, while cross-element communication is mediated only through interface terms (Duan et al., 22 May 2026).

The local volume operator is parameterized by learned query, key, and value maps,

$h$8

and written componentwise as

$h$9

The integral is approximated by Monte Carlo quadrature over sampled element points $g$0,

$g$1

with $g$2 for a $g$3 window (Duan et al., 22 May 2026).

The face term is likewise discretized by sampled boundary points,

$g$4

and expressed in operator-matrix form through interface summaries on the two sides of a face. A lightweight zero-order approximation, called P0DG, replaces explicit face integration by fluxes formed directly from neighboring cellwise volume operators,

$g$5

yielding the DGNO-Cell variant (Duan et al., 22 May 2026).

The global discrete assembly on one element is

$g$6

This gives DGNO its characteristic combination of locality, heterogeneity modeling, and global coherence: locality through $g$7, interface exchange through $g$8, and domain-wide consistency through assembly of all element contributions (Duan et al., 22 May 2026).

3. Relation to classical discontinuous Galerkin methodology

DGNO is explicitly described as DG-inspired rather than as a DG discretization of an image-restoration PDE (Duan et al., 22 May 2026). The classical DG reference point is a PDE

$g$9

whose elementwise weak form reads

$K(x,y;\xi,\eta)$0

For a conservative operator $K(x,y;\xi,\eta)$1, integration by parts produces the standard DG volume–boundary split,

$K(x,y;\xi,\eta)$2

and replacing the physical boundary flux by a numerical flux $K(x,y;\xi,\eta)$3 yields the weak form

$K(x,y;\xi,\eta)$4

DGNO borrows exactly the elementwise decomposition, broken representation, and weak inter-element coupling via fluxes, but applies them at the operator level rather than deriving them by integration by parts from the neural-operator kernel (Duan et al., 22 May 2026).

This distinction matters. The neural-operator integral

$K(x,y;\xi,\eta)$5

does not naturally yield a volume/surface split at the continuous level. DGNO therefore introduces the DG decomposition deliberately as a discretization strategy: restrict the operator to local elements and reintroduce lost cross-element interactions through interface operator fluxes. That makes the method physics-aligned with spatially varying optical blur, but not a PDE solver in disguise (Duan et al., 22 May 2026).

The appendices specify several operator-valued fluxes. The central flux is

$K(x,y;\xi,\eta)$6

the jump flux is

$K(x,y;\xi,\eta)$7

the average-plus-jump flux is

$K(x,y;\xi,\eta)$8

and the upwind-style flux uses a data-dependent weight

$K(x,y;\xi,\eta)$9

to define

$K$0

Boundary conditions are also imposed operator-wise: Dirichlet by replacing the exterior operator with a boundary operator, homogeneous Neumann by evaluating $K$1, and periodic boundaries by pairing faces as ordinary interfaces (Duan et al., 22 May 2026).

4. Architecture, loss, and empirical performance in pathology defocus deblurring

The DGNO deblurring pipeline lifts a blurred image into a latent feature hierarchy, applies DG operator layers, and projects the refined latent state back to image space (Duan et al., 22 May 2026). The reported lifting architecture uses four scales with channel dimensions

$K$2

and encoder module counts

$K$3

The implementation description mentions a MambaIRv2-style lifting backbone. The DG operator itself uses multi-head query–key–value parameterization with $K$4, $K$5, and per-head dimensions $K$6. The highest-scale 384-channel feature is upsampled and fused with the 192-channel feature before the integral operator, and the number of operator iterations is

$K$7

Non-overlapping elements have size $K$8, which function as DG cells $K$9 (Duan et al., 22 May 2026).

Two architectural variants are reported. DGNO-Face computes explicit interface operators by sampling along patch boundaries. DGNO-Cell uses the P0DG cellwise approximation in which interface coupling is assembled directly from neighboring cellwise volume operators. The paper describes the face-based version as more expressive and boundary-aware, while the cell-based version is lighter (Duan et al., 22 May 2026).

Training uses a combined multi-scale spatial and frequency-domain loss,

$u(\cdot)=G(a(\cdot)),$0

$u(\cdot)=G(a(\cdot)),$1

$u(\cdot)=G(a(\cdot)),$2

Reported optimization settings are AdamW with $u(\cdot)=G(a(\cdot)),$3, $u(\cdot)=G(a(\cdot)),$4, weight decay $u(\cdot)=G(a(\cdot)),$5, initial learning rate $u(\cdot)=G(a(\cdot)),$6, cosine decay to $u(\cdot)=G(a(\cdot)),$7, batch size 8, training patch size $u(\cdot)=G(a(\cdot)),$8, and horizontal and vertical flips for augmentation. Hardware is an NVIDIA RTX 4090 with 48 GB (Duan et al., 22 May 2026).

The datasets listed are BBBC006, 3DHistech, DPDD, and RealDOF. BBBC006 contains fluorescence microscopy images at resolution $u(\cdot)=G(a(\cdot)),$9, with two channels, in-focus plane $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$0, and defocused inputs $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$1; the paper reports 6,144 image pairs with a 4:1 train/test split. 3DHistech contains 94,973 patches of size $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$2, split into 66,976 train, 9,088 val, and 18,909 test (Duan et al., 22 May 2026).

The main reported metrics are PSNR, SSIM, and LPIPS. On BBBC006w1, DGNO-Face is reported at 37.09 dB, SSIM 0.958, LPIPS 0.104, and DGNO-Cell at 37.22 dB, SSIM 0.959, LPIPS 0.103; the best prior baselines listed in the table are MPT+EFCR at 35.44 dB and Restormer at 35.35 dB. On BBBC006w2, DGNO-Face reports 32.66 dB, SSIM 0.847, LPIPS 0.323, and DGNO-Cell 32.54 dB, SSIM 0.848, LPIPS 0.322. On 3DHistech, DGNO-Face reports 34.02 dB, SSIM 0.890, LPIPS 0.095, and DGNO-Cell 34.00 dB, SSIM 0.890, LPIPS 0.093. On DPDD, DGNO-Face reports 26.42 dB, SSIM 0.814, LPIPS 0.173. On RealDOF, DGNO reports 25.08 dB, SSIM 0.781, LPIPS 0.275 (Duan et al., 22 May 2026).

Ablations reinforce the intended DG interpretation. Relative to a global Galerkin neural operator baseline, Table 2 reports the progression SRNO at 36.71 dB, SRNO+WIN at 36.85 dB, DGNO-Face at 37.07 dB, and DGNO-Cell at 37.21 dB on BBBC006w1. Region-wise analysis reports improvements of $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$3 dB in edge-band regions and $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$4 dB in non-edge regions relative to the global Galerkin baseline. On synthetic spatially varying Gaussian blur, the reported gains are from 34.69 dB to 38.96 dB for sigma range 8–10 and from 44.24 dB to 46.23 dB or 46.32 dB for sigma range 0.6–13. Downstream cell detection with StarDist yields mean AP 0.3154 on blurred input, 0.5350 for MPT+EFCR, 0.5540 for DGNO-Face, 0.5561 for DGNO-Cell, and 0.5758 for the sharp upper bound (Duan et al., 22 May 2026).

The reported model complexity is about 12.79M parameters and roughly 50 GFLOPs. Appendix Table 11 is described as showing that DGNO consistently uses less memory and maintains higher throughput at larger resolutions; for the largest tested size it is listed at roughly 15 GB / 10 img/s. This suggests that the element-wise DG decomposition functions not only as a modeling prior for local discontinuities but also as the basis of the method’s scalable high-resolution behavior (Duan et al., 22 May 2026).

5. Related DG-based neural methods and broader DGNO interpretations

Several papers situate DGNO within a broader landscape of DG-neural methods, but they do so with substantially different goals. DG-FEONet is a data-free operator learning framework for parametric elliptic and convection–diffusion–reaction PDEs with discontinuous coefficients. It represents the solution as

$z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$5

with $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$6, where the basis $z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$7 spans the broken polynomial space

$z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$8

Training minimizes the residual of the SIPG weak form,

$z_0(x)=P(a(x)), \qquad u(x)=Q(z_T(x)),$9

or equivalently $$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$0 after assembly. Because the network learns a parameter-to-coefficient map over a family of PDEs, this is close in substance to a DG neural operator, although the paper names it DG-FEONet rather than DGNO (Chawla et al., 7 Jan 2026).

DGNet, or DGNN, is different. It is a solver for a single PDE instance rather than an amortized operator learner. Its trial space is piecewise neural,

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$1

with one local network per element and a polynomial DG test space. The loss combines local weak residuals, interface penalties,

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$2

and initial-condition mismatch where needed (Chen et al., 13 Mar 2025). DGNN in a later abstract framework generalizes this least-squares residual-minimization view, defines a broken quadratic functional with element, boundary, initial, and interface terms, and proves recursive error contraction for iteratively enriched element-wise neural trial sets (Yuan et al., 9 Nov 2025). These methods are DG-neural and operator-like in structure, but not neural operators in the train-once, infer-many sense.

DGPWNN pushes the DG-neural idea toward wave physics. For Helmholtz and Maxwell equations it uses an element-wise plane-wave neural ansatz

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$3

inside a DG/Trefftz least-squares formulation with interface penalties on jumps of traces and normal derivatives. The method recursively augments the local basis by quasi-maximizing a residual indicator and proves convergence without assuming bounded neural parameters (Yuan et al., 11 Jun 2025). This suggests a DGNO design principle in which local channels are chosen to be physics-aligned local modes rather than generic latent features.

A separate but related line learns DG closures rather than full operators. The artificial-viscosity method for 1D hyperbolic conservation laws inserts a neural viscosity law

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$4

into a DG time-stepping scheme for

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$5

and trains it by differentiating through many DG updates (Bois et al., 2023). This is not a DGNO, since the network learns only a stabilization component and not the solution operator. Yet it demonstrates a key DGNO-adjacent capability: DG solvers can be made differentiable and coupled end-to-end to learned modules.

The incomplete NODE-DG manuscript is a special case. Its metadata presents a differentiable DG solver with a neural network source term and NODE optimization for compressible Navier–Stokes equations, but the supplied manuscript text is an empty template, so the method cannot be technically verified from the available document (Kang et al., 2023). A plausible implication is that nomenclature around DG neural operators remains fluid: some papers use the term for explicit DG-structured neural operators, whereas others present DG-neural hybrids whose operator status depends on whether the learned component maps between function spaces or acts only as a local correction.

6. Misconceptions, limitations, and open directions

A common misconception is that any method combining a DG mesh with a neural network is automatically a DG neural operator. The literature in the data block does not support that equivalence. DGNO in pathology deblurring is an explicit neural-operator architecture: it starts from the neural-operator layer

$$z_{t+1}(x)=\sigma\!\left(W z_t(x) + (K z_t)(x)\right),$$6

and replaces the global kernel by a DG-style element and interface decomposition (Duan et al., 22 May 2026). DG-FEONet is operator learning over parameter space in a DG coefficient basis (Chawla et al., 7 Jan 2026). By contrast, DGNet, DGNN, and DGPWNN solve one problem instance at a time through variational optimization (Chen et al., 13 Mar 2025, Yuan et al., 9 Nov 2025, Yuan et al., 11 Jun 2025), and the artificial-viscosity framework learns only a DG closure (Bois et al., 2023).

A second misconception is that DGNO is a classical DG discretization of a governing PDE. The deblurring paper states the opposite: the DG decomposition is not derived by integration by parts from the neural-operator integral, because the integral operator does not naturally split into volume and surface terms. Instead, DGNO imports the modularity of DG as a deliberate architectural prior for spatially varying, locally discontinuous operator behavior (Duan et al., 22 May 2026).

Several limitations are explicit or strongly implied. In pathology deblurring, DGNO is still a learned inverse model rather than a calibrated forward–inverse optical model with explicit PSF estimation (Duan et al., 22 May 2026). Its performance depends on the element partition; much larger elements degrade results, consistent with loss of local heterogeneity. The P0DG cell variant can lose fine boundary information under stronger defocus. The paper develops no approximation, consistency, or stability theory for the learned DG operator. This suggests that current DGNO work is stronger on architectural inductive bias and empirical validation than on operator-theoretic guarantees.

The broader DG-neural literature points to several natural extensions. DG-FEONet is mesh-specific because it predicts a DG coefficient vector on a fixed discretization (Chawla et al., 7 Jan 2026). DGNN and DGPWNN emphasize local discontinuous trial spaces and weak interface coupling but lack amortized generalization across PDE instances (Yuan et al., 9 Nov 2025, Yuan et al., 11 Jun 2025). The learned-viscosity approach shows how DG components can be trained through rollout, but not how to obtain a mesh-transferable full operator (Bois et al., 2023). This suggests an emerging research agenda centered on shared local element encoders, interface message-passing modules that act as learned fluxes, adaptive or geometry-aware partitions, and DG-consistent losses that preserve the locality/interface structure while moving from per-instance solvers toward train-once operator learning.

In that sense, DGNO is best understood as both a specific architecture and a methodological direction. In the narrow sense, it is the discontinuous-Galerkin neural operator introduced for pathology defocus deblurring, with element-local volume operators and interface numerical fluxes (Duan et al., 22 May 2026). In the broader sense, it names a family resemblance across DG-structured neural methods: broken local representations, weak coupling through interfaces, and learned maps organized around the same volume–face decomposition that makes DG effective for discontinuous and heterogeneous problems.