Batch-Based Convergent Born Series (BCBS)

• BCBS is a memory-efficient strategy that generates neural operator training pairs online by batching GPU-based CBS solves, bypassing expensive offline dataset generation.
• It implements a batched tensor formulation that uses FFT-based Green’s solvers and preconditioned iterations to simultaneously resolve multiple Helmholtz equations.
• BCBS reduces I/O and storage bottlenecks in USCT inverse problems while ensuring convergence in challenging settings with strong scattering and noise.

Searching arXiv for the specified paper and closely related CBS background. Search query: arXiv (Cao et al., 22 Jul 2025) Diff-ANO Batch-based Convergent Born Series; Osnabrugge convergent Born series 2016 Batch-based Convergent Born Series (BCBS) is a memory-efficient strategy for online generation of neural-operator training pairs within the Diff-ANO framework for ultrasound computed tomography (USCT). It is introduced as a practical mechanism for replacing prohibitively expensive offline dataset generation with batched GPU evaluation of Convergent Born Series (CBS) solves, thereby supporting adjoint operator learning for Helmholtz-equation–constrained inverse problems. In the formulation reported for Diff-ANO, BCBS is tied to high-resolution USCT, where nonlinear scattering, sparse or partial angular coverage, and noise make the inverse problem ill-posed, and where diffusion-based priors and neural operator surrogates are used to improve both reconstruction quality and computational efficiency (Cao et al., 22 Jul 2025).

1. Problem setting in Helmholtz-equation–constrained USCT

BCBS is motivated by the forward model used in USCT. The objective is to recover a spatially varying sound-speed map $c(\mathbf r)\equiv c_0(\mathbf r)$ on a domain $\Omega$ from measurements

$y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$

where, for each source $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$, the forward wavefield $u_n$ solves

$$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$

with absorbing boundary conditions. The reported sources of ill-posedness are noise, incomplete angular coverage under sparse-view or partial-view acquisition, and strong multiple scattering, described as “cycle skipping” (Cao et al., 22 Jul 2025).

Within Diff-ANO, this forward model is not merely a simulator; it is also the source of supervision for learning a neural operator surrogate. The paper states that training such a surrogate for Helmholtz forward and adjointed solves requires large numbers of $(c_0,u)$ pairs. Pre-computing and storing these pairs offline for thousands of phantoms and multiple sources is described as prohibitively expensive in GPU memory and I/O. BCBS is introduced precisely to avoid that bottleneck by generating training pairs online in small GPU batches.

2. From the classical Born iteration to the Convergent Born Series

The development of BCBS rests on the distinction between the classical Born series and the Convergent Born Series. The classical rewriting introduces a constant reference wavenumber $k_0=\omega/c_{\rm bg}$ and the scattering potential

$$V(\mathbf r) = k(\mathbf r)^2 - k_0^2 - i\,\epsilon, \qquad k(\mathbf r)=\omega/c_0(\mathbf r),$$

so that the Helmholtz equation becomes

$$\bigl[\nabla^2 + k_0^2 + i\epsilon\bigr]\,u_n = -\,\rho_n \;-\; V\,u_n.$$

By inverting the background operator with the Green’s operator

$\Omega$0

one obtains the standard Born iteration

$\Omega$1

The limitation of the classical scheme is explicit: convergence requires $\Omega$2, and this condition fails in strongly scattering media. BCBS therefore does not build on the classical Born iteration directly; it builds on the preconditioned CBS formulation attributed in the paper to Osnabrugge et al. (2016).

In the CBS formulation,

$\Omega$3

The wavefield is then represented as

$\Omega$4

The paper states that for any $\Omega$5 one shows $\Omega$6, and that CBS is guaranteed to converge, in $\Omega$7 or spectral norm, regardless of scattering strength (Cao et al., 22 Jul 2025).

A more explicit preconditioned iteration is also given: $\Omega$8 with $\Omega$9 and truncated iterate

$y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$0

The convergence condition is reported as

$y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$1

by a Gårding inequality and the choice $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$2, implying

$y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$3

In practice, $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$4 is chosen so that $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$5.

3. BCBS as a batched GPU realization of CBS

BCBS takes the CBS iteration and lifts it to a batched tensor formulation. The construction begins by sampling a mini-batch of $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$6 speed maps $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$7 and fixing $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$8 source patterns $y_{m,n}^\delta = u_n(\mathbf r_m) \;+\;\eta_{m,n},$9. Two product arrays are formed: $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$0 Through broadcasting, these arrays represent $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$1 distinct Helmholtz solves at once.

The batched scattering potentials and preconditioners are then computed as

$\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$2

The batched Green’s solve $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$3 is defined via FFT on the last two dimensions, and the batched iteration operator

$\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$4

is given by

$\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$5

where $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$6 is pointwise in space and broadcast in batches.

The central computational step is a single-kernel iteration. With $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$7, the update for $\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$8 is

$\rho_n(\mathbf r)=\delta(\mathbf r-\mathbf r_n^s)$9

After $u_n$0 steps, $u_n$1 is the CBS solution for speed map $u_n$2 and source $u_n$3.

The accompanying pseudocode specifies the same procedure operationally: compute $u_n$4 for all $u_n$5, set $u_n$6 and $u_n$7, broadcast $u_n$8 to shape $u_n$9, precompute $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$0 by FFT-solving each $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$1 with the reference operator, initialize $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$2, and iterate

$$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$3

4. Memory, complexity, and execution profile

The explicit rationale for BCBS is computational. Its memory footprint is described as requiring only the storage of $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$4, $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$5, and buffers of size $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$6, with no offline storage of all training pairs (Cao et al., 22 Jul 2025). This is the key architectural distinction from offline dataset generation.

The asymptotic cost reported for CPU-based CBS is $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$7 for a single solve. BCBS performs $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$8 solves in parallel at roughly the same wall time as one solve, plus batching overhead. The paper attributes the acceleration to batched GPU kernels and to amortization of FFT overhead across many simultaneous solves.

The practical settings and timing figures given in the paper are summarized below.

Quantity	Reported value
Batch size $$\bigl[\nabla^2 + \tfrac{\omega^2}{c_0(\mathbf r)^2}\bigr]\,u_n(\mathbf r) = -\,\rho_n(\mathbf r), \quad \mathbf r\in\Omega,$$9	$(c_0,u)$0
Sources per batch $(c_0,u)$1	$(c_0,u)$2
Iteration count $(c_0,u)$3	$(c_0,u)$4–$(c_0,u)$5
CBS error target	below $(c_0,u)$6
GPU timing	BCBS on A100 delivers $(c_0,u)$7 s per epoch for $(c_0,u)$8 solves vs $(c_0,u)$9 h if done serially on CPU
Single-sample timing	CBS-solver (CPU): $k_0=\omega/c_{\rm bg}$0 h; BCBS-solver (GPU): $k_0=\omega/c_{\rm bg}$1 s; full forward-adjoint neural-operator accelerated sampling: $k_0=\omega/c_{\rm bg}$2 s

These figures should be read in the context provided by the paper: the iteration count reflects a trade-off between speed and ground-truth accuracy, and the timing comparison distinguishes among raw CPU CBS, batched GPU CBS, and the separate inference-time regime that uses trained neural operators rather than direct CBS evaluation.

5. Role in neural-operator supervision and Diff-ANO inference

BCBS is embedded in the training pipeline for the adjoint neural operator surrogate denoted $k_0=\omega/c_{\rm bg}$3. Its function is to provide on-the-fly supervision in the form of tuples $k_0=\omega/c_{\rm bg}$4 (Cao et al., 22 Jul 2025). The minibatch training objective is

$k_0=\omega/c_{\rm bg}$5

The parameters $k_0=\omega/c_{\rm bg}$6 are then updated by backpropagation through $k_0=\omega/c_{\rm bg}$7.

A point the paper makes explicitly is that BCBS itself does not use any measurement $k_0=\omega/c_{\rm bg}$8. It is purely the physics-based ground-truth generator. This addresses a likely misunderstanding: BCBS is not the measurement-conditional component of Diff-ANO. Measurement conditioning belongs instead to the conditional consistency model used during inference. During Diff-ANO sampling, the trained $k_0=\omega/c_{\rm bg}$9 is used to compute forward wavefields and adjoint gradients in each consistency-model sampling step.

In this sense, BCBS occupies a specific layer of the overall architecture. Diff-ANO combines conditional consistency models with adjoint operator learning; BCBS is the mechanism that makes large-scale supervision for the latter practical. A plausible implication is that the quality and throughput of BCBS directly affect how effectively the surrogate can replace traditional PDE solvers in the downstream sampling loop.

6. Significance, limitations, and possible extensions

The paper identifies two immediate reasons why BCBS matters. First, it eliminates the I/O and storage bottleneck associated with large offline Helmholtz datasets. Second, it leverages single GPU kernels to amortize the overhead of FFTs across hundreds of solves (Cao et al., 22 Jul 2025). In the context of USCT, where strongly scattering media invalidate the ordinary Born convergence condition, the use of CBS rather than the classical Born iteration is foundational to this design.

The limitations are also stated directly. BCBS relies on the specific form of Born-type series and on the availability of a fast background Green’s solver via FFT. Moreover, although CBS is guaranteed to converge, its convergence speed can still be slow if the contrast is extremely high and $$V(\mathbf r) = k(\mathbf r)^2 - k_0^2 - i\,\epsilon, \qquad k(\mathbf r)=\omega/c_0(\mathbf r),$$0 barely satisfies the preconditioner bound. This qualifies a potential misconception that convergence guarantees automatically imply uniformly fast execution.

The extension paths proposed in the paper remain within the same algorithmic template. Any inverse problem solved by a fixed-point or Neumann-series solver, including Lippmann–Schwinger for waves and iterative Born for ODT, is presented as a candidate for similar batching. More advanced preconditioners or acceleration methods, specifically Chebyshev and Krylov schemes, may also be batched similarly. The paper additionally suggests combination with multi-scale subspace methods, running first on coarse grids and then refining within a batched pipeline.

Taken together, these points situate BCBS as a specialized but generalizable batching strategy: specialized because it depends on the CBS structure and FFT-accessible background solves, and generalizable because the same batched fixed-point pattern may transfer to other wave-based inverse problems. The reported contribution is therefore not only a GPU implementation detail, but a method for online training-pair generation that preserves memory efficiency while maintaining convergent solvers in strongly scattering ultrasound media (Cao et al., 22 Jul 2025).