Sine-Gordon: bulk-subtracted finite-volume vacuum¶

Status: native and explicit MPFR kernel, vacuum-energy library and bethe-sine-gordon-vacuum frontend implemented. This is a field theory calculation, not a classical sine-Gordon PDE evolution or a finite-site spin-chain diagonalization.

For particle lines, breather masses, continuum onsets and selected asymptotic Bethe–Yang levels, see sine-Gordon excitations. For selected exact same-charge two-soliton levels and vacuum-relative gaps, see the excited-state NLIE solver.

Running the vacuum solver¶

bethe-sine-gordon-vacuum --length 1 --p 2
bethe-sine-gordon-vacuum --mass 2 --length 0.5 --p 0.5 --json vacuum.json
bethe-sine-gordon-vacuum --length 1 --p 1 --precision fp128 --csv vacuum.csv

--length and --p are required; --mass defaults to one. All real inputs are parsed directly in the chosen precision: fp64 (default), long-double, configured fp128, or bits-N / digits-N with MPFR/MPC enabled. MPFR vacuum solves do not require MPLAPACK. The last example is the free Dirac check; interacting high-precision runs can take minutes.

For example, the free Dirac result at 256 bits needs more mesh refinement:

bethe-sine-gordon-vacuum --length 1 --p 1 --precision bits-256 --max-intervals 8192

More arithmetic bits do not increase numerical work limits. At tight tolerances, raise --max-kernel-evaluations as needed (for example, 1000000) as well as the rapidity mesh budget. A value meeting one refinement comparison still needs the second confirmation; exhausting the budget before that remains an incomplete solve. The two contours, kernel tail, mesh, cutoff and nonlinear tests stay independent. MPFR scales and all controls must share a finite precision:

using R = uni20::mpreal;
auto precision = uni20::Precision::bits(160);
bethe::sine_gordon::VacuumOptions<R> controls(precision);
controls.max_intervals = 8192;
controls.kernel.max_evaluations = 1000000;
auto state = bethe::sine_gordon::vacuum_energy(
    R(1, precision), R(30, precision), R(2, precision), controls);

Failure results retain their precision and separate diagnostics; they do not publish an energy. Exact, unset or mixed-precision inputs are rejected before any output file is opened.

The single vacuum table reports casimir_energy (E_C), scaling_function (Y), effective_central_charge, separate convergence diagnostics and work counters. These are not a total absolute energy or an energy per lattice site. The metadata records physical conventions, both numerical contour shifts, input controls, provenance and CPU time. See output and exports for JSON/CSV/TSV, streaming and overwrite protection. Literature appears with --references, not on each ordinary run.

--tolerance is an absolute tolerance in Y, default \(262144\,\epsilon\) in the selected precision. --contour-shift and --initial-cutoff override the automatic contour and rapidity cutoff choices described below. --initial-intervals (64) and --max-intervals (2048) control rapidity resolution; --max-iterations (10000) is the total nonlinear-update budget across all meshes and both contours. --max-cutoffs (3) limits rapidity cutoff attempts per contour. Independently, --max-kernel-evaluations (100000), --max-kernel-levels (16) and --max-fourier-cutoffs (64) limit each Fourier kernel table construction. Kernel accuracy is assigned from the vacuum error budget, not a separate user tolerance.

Exit status is 0 on convergence, 1 for invalid input/output errors, and 2 for an incomplete solve. On status 2 all three physical observables are missing (JSON null, empty CSV/TSV cells); diagnostics remain available. Unknown error estimates may be infinite. Numerical validation precedes opening output files, including when --force is given.

Physical convention¶

Use the canonically normalized kinetic term (1/2)(partial phi)^2, coupling \(0 \lt \beta ^{2} \lt 8\,\pi\), and the parameter

\[ p=\frac{\beta^2}{8\pi-\beta^2}. \]

Then p>1 is repulsive, 0<p<1 attractive, and p=1 the free massive Dirac point. In Rutkevich's normalization, his beta squared is our \(\beta ^{2}/(8\,\pi)\), his xi is p, and his gamma is pi/(1+p). State these conventions explicitly; the different meanings of beta must not be mixed.

Take the soliton mass M as the physical input scale, set velocity and hbar to one, and use \(u =M \,L\). The observable is the bulk-subtracted vacuum energy \(E_{C} =E_{0} -L \,e_{\mathrm{bulk}}\), or the dimensionless scaling function \(Y =L \,E_{C}\). No nonuniversal absolute bulk energy is inferred. In the attractive regime M still denotes the soliton mass, not necessarily the lightest breather mass.

The starting point is Destri–de Vega. For explicit shifted-contour formulas and checks on normalization we use Rutkevich (2020), equations (22), (68), (69).

Implemented kernel¶

#include <bethe/sine_gordon.hpp>
auto g = bethe::sine_gordon::scattering_kernel(std::complex<double>(0.8, 0.4), 2.7);
if (g.converged) {
  // *g.value is the complex kernel, not an energy.
}

The kernel is

\[ G_p(z)=\int_0^\infty\frac{\cos(kz)}{2\pi} \frac{\sinh[(p-1)\pi k/2]}{\sinh(p\pi k/2)\cosh(\pi k/2)}\,dk. \]

Its Fourier representation is used only inside |Im(z)| < pi*min(1,p). Invalid couplings, nonfinite arguments, points outside this strip and nonpositive tolerances throw. We enforce the same strip at p=1 even though the identically zero kernel can itself be continued further.

KernelOptions<Real> provides an absolute component tolerance (1024 epsilons at the working precision), up to 100000 integrand evaluations, 16 quadrature levels, and 64 Fourier-cutoff attempts. All arithmetic stays in the chosen native or explicit MPFR/MPC precision. The implementation reuses the common compensated tanh-sinh quadrature; it does not introduce a double-only special-functions dependency.

The hyperbolic ratio is evaluated with expm1 and decaying exponentials. For complex arguments, growth from \(\cos (k \,z)\) is combined with the Fourier decay before either factor is evaluated. This avoids an overflowing cosh multiplied by an underflowing ratio on otherwise legal contours. The same formula retains the small multiplier for p only a few native epsilons from one.

Let d=pi*min(1,p)-|Im(z)|>0. Beyond a cutoff K, an absolute tail bound is

\[ \frac{e^{-dK}}{\pi d(1-e^{-p\pi K})}. \]

The returned tail_bound and quadrature_error are separate. The latter is a successive-mesh estimate, not a rigorous enclosure. A kernel value is optional and is published only when their sum meets the requested tolerance. Failure statuses distinguish cutoff, quadrature and finite-range limitations. Unknown error diagnostics remain infinite rather than appearing to be zero.

Independent checks include the exact transforms

\[ \begin{aligned} G_{1/2}(z)&=-\frac1{2\pi\cosh z},\\{} G_2(z)&=\frac{z}{2\pi^2\sinh z},\qquad G_2(0)=\frac1{2\pi^2},\\{} G_1(z)&=0,\qquad \left.\frac{\partial G_p(0)}{\partial p}\right|_{p=1}=\frac18. \end{aligned} \]

The first two are test references, not implementation shortcuts. Tests also cover evenness, complex conjugation, a separate 90-digit quadrature reference, overflow-prone Fourier factors, native near-free couplings, and failure budgets.

Vacuum-energy API¶

#include <bethe/sine_gordon_vacuum.hpp>
auto state = bethe::sine_gordon::vacuum_energy(1.0, 2.0, 0.7); // M, L, p
if (state.converged) {
  // *state.casimir_energy = E0-L*e_bulk
  // *state.scaling_function = L*state.casimir_energy
  // *state.effective_central_charge = -6*Y/pi
}

The library accepts finite positive M, L and p. It follows the untwisted vacuum branch in both regimes; difficult parameters can exhaust a numerical budget. It does not return the bulk energy density or an excited-state spectrum.

VacuumOptions<Real> controls:

tolerance: absolute accuracy target in Y, default 262144 native epsilons. This is not a relative guarantee for exponentially small infrared energies.
initial_intervals=64, max_intervals=2048: an even, uniform rapidity mesh, doubled until two successive energy differences are below tolerance/4. The explicit work ceiling is 16384 intervals; it is not a convergence promise.
max_iterations=10000: total damped nonlinear updates across all meshes, cutoffs and both contours, rather than a hidden budget per retry.
max_cutoffs=3: cutoff attempts per contour, each separately mesh-resolved. Consecutive cutoffs differ by one rapidity unit and must agree within tolerance/4.
Optional initial_cutoff and contour_shift; defaults estimate a safe tail scale and use \(\eta =\pi \,\min (1,p)/4\). The second independently resolved contour is \(3\,\eta /4\), and must agree in Y within tolerance/2.
kernel: Fourier evaluation/level/cutoff budgets per table. Its tolerance is assigned internally from the vacuum tolerance and rapidity cutoff.

nonlinear_residual, kernel_error, mesh_error, cutoff_error and contour_error are reported separately. These mesh/cutoff comparisons are numerical estimates, not rigorous interval bounds. intervals and cutoff report the larger final resolved sizes of the two contours; work counters include unsuccessful earlier attempts. A small nonlinear residual cannot by itself produce converged=true.

All three observables are optional and remain absent on kernel_limit, iteration_limit, mesh_limit, cutoff_limit, contour_limit or precision_limit. Invalid parameters throw before iteration; unrepresentable scaled lengths or energies fail without publishing values. A branch guard keeps the logarithm argument in its open right half-plane. A transient pseudoenergy with negative real part alone is not rejected: this occurs during perfectly regular attractive ultraviolet iterations.

Shifted-contour vacuum NLIE¶

For \(0 \lt \eta \lt \pi \,\min (1,p)/2\), use

\[ \begin{aligned} A(\theta)&=\log(1+e^{-\epsilon(\theta)}),\\{} \epsilon(\theta)&=-iu\sinh(\theta+i\eta) -\int G_p(\theta-t)A(t)\,dt +\int G_p(\theta-t+2i\eta)\overline{A(t)}\,dt,\\{} Y&=-\frac u\pi\mathrm{Im}\int\sinh(\theta+i\eta)A(\theta)\,d\theta. \end{aligned} \]

The finite contour shift regularizes the counting-function logarithms without crossing kernel poles. Do not move directly to eta=pi/2 in the attractive regime. The chosen eta is numerical, not a physical model parameter: agreement at two independently resolved shifts is an important check.

The implementation tabulates real and shifted kernels on a difference grid, using shared native Gauss-Legendre quadrature and compensated sums. The Fourier multiplier is computed once per quadrature point for all displacements; short phase recurrences reduce repeated trigonometric calls. The standalone tanh-sinh kernel provides an independent check of this tabulation. Its Fourier tail bound is unchanged. Two successive Fourier-mesh agreements are required. Native arithmetic retains the 16-point rule. MPFR raises the Gauss order with working precision (between 16 and 128); every node still counts against the explicit evaluation budget. This increases quadrature order before panel refinement without changing the Fourier cutoff bound or accepting a single agreement.

The unknown is the correction to the analytically known driving term, updated with half damping. Vacuum parity epsilon(-theta)=conj(epsilon(theta)) reduces the convolution cost. The complex logarithm utility is shared with ASEP. Convolution is currently quadratic in mesh size: a demanding fp128 solve can take minutes in a Debug build. No FFT or lower-precision fallback is used.

Validation and remaining scope¶

All precisions check the free-Dirac integral against an independent high-precision reference, and the interacting p=2 result against an independent, real-valued D3 TBA calculation with two separately refined Gauss meshes. The latter uses the equations summarized in Hegedus (2026), (2.6)-(2.8), with the magnon plateau integrated analytically.

Further tests cover attractive/repulsive couplings, mass-length scaling, altered contours, the ultraviolet \(c_{\mathrm{eff}} \to 1\) limit, and the leading soliton plus breather wrapping correction at p=1/2. They also distinguish nonlinear, kernel, rapidity-mesh and cutoff failures, and verify that failed states have no published observables.

The MPFR tests compare the free Dirac result at 80/160/256/333 bits with 110/140-decimal-digit real-axis integrals. Closed Fourier transforms test both real and shifted kernel tables at the same precisions. The independent D3 reference at scaled length 30 uses 384-bit arithmetic; 1536 and 2048 Gauss points differ by less than \(6\times10^{-112}\). Its nonlinear precision-growth check requires absolute error in Y below \(10^{-40}\) at 160 bits and runs as a separate long test. Free-Dirac and closed-transform checks demonstrate accuracy growth through 333 bits; arithmetic and discretization remain separate. Reference generators are reference_sine_gordon_vacuum.py and reference_sine_gordon_d3.cpp. Build the latter with target bethe_sine_gordon_d3_reference and run ./tests/bethe_sine_gordon_d3_reference 2048 384 30 from the build directory.

Owning mixed-precision Async sweeps compare every result and diagnostic against direct solves under deferred and one/two-worker scheduling, including failures. The single-scale vacuum CLI stays serial. Frontend regressions check complete JSON/CSV/TSV precision, parsing, streaming, budget forwarding, missing failed observables and protection of existing files on invalid input.

This first target is the untwisted zero-topological-charge vacuum. Excited states require additional source terms and branch/quantization bookkeeping; large-volume Bethe–Yang equations alone are not an exact finite-volume solver.