Domain: Physics — High-energy particle physics

Problem:
Consider a real scalar field \( \phi \) in a four-dimensional Euclidean space with \( O(4) \) symmetry. 

The Euclidean action is defined by:

\[
S_E[\phi] = 2\pi^2 \int_{0}^{\infty} r^3 
\left[\frac{1}{2}\left(\frac{d\phi}{dr}\right)^2 + V(\phi)\right] dr,
\]

where the scalar potential is given as:

\[
V(\phi) = \frac{\lambda}{8}(\phi^2 - v^2)^2 + \delta\,\phi,
\qquad 
\lambda = \tfrac{1}{2}, \quad v = 1, \quad \delta = 0.02.
\]


Let \( \phi_{\mathrm{tv}} \) and \( \phi_{\mathrm{fv}} \) denote the true and false vacuum minima of the potential \(V(\phi)\), respectively.

The bounce configuration \( \phi_b(r) \) satisfies the nonlinear ordinary differential equation:

\[
\phi''(r) + \frac{3}{r}\phi'(r) = \frac{dV}{d\phi}(\phi),
\qquad 
\phi'(0) = 0, \qquad \lim_{r \to \infty} \phi(r) = \phi_{\mathrm{fv}}.
\]

The objective is to determine the Euclidean action difference
\[
B = S_E[\phi_b] - S_E[\phi_{\mathrm{fv}}],
\]
which represents the tunneling exponent governing false vacuum decay.

To make the computation fully reproducible, the numerical procedure is fixed as follows.  
The radial coordinate lies in the interval \( r \in [0, r_{\max}] \) with \( r_{\max} = 20.0 \).  
A uniform grid of \( N = 40{,}000 \) intervals is used, corresponding to a step size \( \Delta r = r_{\max}/N \).  
To regularize the origin, the factor \( 3/r \) in the equation is replaced by \( 3/(r + \varepsilon) \) with \( \varepsilon = 10^{-12} \).  

The differential equation is integrated using the classical fixed-step fourth-order Runge–Kutta (RK4) method applied to the equivalent first-order system, with no adaptive step-size control.

The initial field value \( \phi_0 = \phi(0) \) is determined by a bisection search consisting of exactly eighty iterations.  
The search interval is :

\[
\phi_0 \in (\phi_{\mathrm{tv}} + 10^{-6},\, \phi_{\mathrm{top}} - 10^{-6}),
\]

where \( \phi_{\mathrm{top}} \) is the field value at which \( V(\phi) \) attains its local maximum between the two minima.  
For a given trial \( \phi_0 \), define:

\[
F(\phi_0) = \phi(r_{\max}; \phi_0) - \phi_{\mathrm{fv}}.
\]
The correct value of \( \phi_0 \) is the one that produces a sign change in \( F(\phi_0) \).  
The iteration terminates when \( |\phi_0^{(k+1)} - \phi_0^{(k)}| < 10^{-12} \) or after eighty iterations, whichever occurs first.

The true and false vacua \( \phi_{\mathrm{tv}} \) and \( \phi_{\mathrm{fv}} \) are located by solving \( V'(\phi) = 0 \) within the interval \( \phi \in [-2, 2] \).  

A uniform scan of forty thousand and one points is performed to detect sign changes in \( V'(\phi) \).  
Each zero is refined using Newton’s method with the analytic second derivative \( V''(\phi) \).  
Only roots satisfying \( V''(\phi) > 0 \) are retained, and the resulting minima are sorted so that \( \phi_{\mathrm{tv}} < \phi_{\mathrm{fv}} \).

Once the bounce profile \( \phi_b(r) \) is obtained, the tunneling exponent is evaluated as:

\[
B = 2\pi^2 \int_{0}^{r_{\max}} r^3\left[
\frac{1}{2}\left(\frac{d\phi_b}{dr}\right)^2+ V(\phi_b(r)) - V(\phi_{\mathrm{fv}})
\right] dr.
\]

The integral is computed using the composite trapezoidal rule over the same grid.  

The derivative \( \frac{d\phi_b}{dr} \) is approximated by central finite differences, implemented through a uniform-spacing numerical gradient.  

The final numerical result for \(B\) must be reported as a single dimensionless number rounded to five significant figures.  
No additional data, plots, or intermediate values should be provided.

Answer: 34520

Solution code:
import numpy as np

# --- Fixed model parameters ---
lam = 0.5
v = 1.0
delta = 0.02

def V(phi):
    return lam/8.0 * (phi**2 - v**2)**2 + delta*phi

def dV(phi):
    return lam/2.0 * phi * (phi**2 - v**2) + delta

def ddV(phi):
    return lam/2.0 * (3*phi**2 - v**2)

# --- Locate minima deterministically ---
def find_minima(phi_left=-2.0, phi_right=2.0, n=40001, newton_steps=60):
    phi_grid = np.linspace(phi_left, phi_right, n)
    d = dV(phi_grid)
    idx = np.where(np.sign(d[:-1]) * np.sign(d[1:]) < 0)[0]
    mins = []
    for i in idx:
        x = 0.5*(phi_grid[i] + phi_grid[i+1])
        for _ in range(newton_steps):
            f = dV(x)
            fp = ddV(x)
            if abs(fp) < 1e-14: break
            x_new = x - f/fp
            if abs(x_new - x) < 1e-14:
                x = x_new
                break
            x = x_new
        if ddV(x) > 0:  # accept minima only
            mins.append(x)
    mins = sorted(mins)
    # expect exactly two minima for this parameter set
    return mins[0], mins[1]

phi_tv, phi_fv = find_minima()

# --- Radial grid and fixed-step RK4 integrator ---
rmax = 20.0
N = 40000
dr = rmax / N
r = np.linspace(0.0, rmax, N+1)
eps = 1e-12  # origin regularization for 3/r

def integrate(phi0):
    phi = phi0
    phip = 0.0
    traj = np.empty_like(r)
    traj[0] = phi
    for i in range(N):
        ri = r[i]
        def acc(phi_local, p_local, ri_local):
            fric = 3.0 / (ri_local + eps)
            return dV(phi_local) - fric * p_local
        # Classical RK4, constant step
        k1_phi = dr * phip
        k1_p   = dr * acc(phi, phip, ri)
        k2_phi = dr * (phip + 0.5*k1_p)
        k2_p   = dr * acc(phi + 0.5*k1_phi, phip + 0.5*k1_p, ri + 0.5*dr)
        k3_phi = dr * (phip + 0.5*k2_p)
        k3_p   = dr * acc(phi + 0.5*k2_phi, phip + 0.5*k2_p, ri + 0.5*dr)
        k4_phi = dr * (phip + k3_p)
        k4_p   = dr * acc(phi + k3_phi, phip + k3_p, ri + dr)
        phi   += (k1_phi + 2*k2_phi + 2*k3_phi + k4_phi)/6.0
        phip  += (k1_p   + 2*k2_p   + 2*k3_p   + k4_p  )/6.0
        traj[i+1] = phi
        # hard clamp to avoid runaway; with given params it won't trigger
        if not np.isfinite(phi) or abs(phi) > 5.0:
            break
    return traj

# --- Bracket and bisection for phi0 ---
def compute_phi_top():
    phis = np.linspace(phi_tv, phi_fv, 2001)
    return phis[np.argmax(V(phis))]

phi_top = compute_phi_top()

def shoot_phi0():
    lo = phi_tv + 1e-6
    hi = phi_top - 1e-6
    def F(phi0):
        return integrate(phi0)[-1] - phi_fv
    Flo = F(lo)
    Fhi = F(hi)
    # ensure opposite signs by nudging hi toward phi_top if needed
    for _ in range(10):
        if np.sign(Flo) != np.sign(Fhi):
            break
        hi = 0.5*(hi + phi_top)
        Fhi = F(hi)
    # Bisection: exactly up to 80 iters or until tight tolerance
    for _ in range(80):
        mid = 0.5*(lo + hi)
        Fmid = F(mid)
        if np.sign(Fmid) == np.sign(Flo):
            lo, Flo = mid, Fmid
        else:
            hi, Fhi = mid, Fmid
        if abs(hi - lo) < 1e-12:
            break
    return 0.5*(lo + hi)

phi0 = shoot_phi0()
traj = integrate(phi0)

# --- Action B ---
V_fv = V(phi_fv)
phip = np.gradient(traj, dr)  # central differences on uniform grid
integrand = 0.5*phip**2 + (V(traj) - V_fv)
B = 2.0 * np.pi**2 * np.trapezoid(r**3 * integrand, r)

# Single deterministic output, 5 significant figures
print(f"{B:.5g}")