Domain: Physics — Quantum Mechanics

Problem:
Given the saturation density \(\rho = 0.16~\mathrm{fm}^{-3}\), we consider symmetric nuclear matter with spin–isospin degeneracy \(g=4\). The Fermi momentum is therefore fixed by
\[
\rho = \frac{g\,k_F^{3}}{6\pi^2}
\quad\Longrightarrow\quad 
k_F = \left(\frac{3\pi^2\rho}{2}\right)^{1/3}.
\]

We perform a Brueckner-Hartree-Fock (BHF) ladder summation using a rank-1 Yamaguchi nucleon–nucleon interaction in momentum space:

\[
V(k,k') 
= -\lambda\,
    \frac{1}{(k^2+\beta^2)}\,
    \frac{1}{(k'^2+\beta^2)},
\]

with parameters
\[
\lambda = 6000~\mathrm{MeV\, fm}^2,
\quad
\beta = 1.5~\mathrm{fm}^{-1}.
\]

For the kinetic energy we use the single–particle convention
\[
\frac{\hbar^2}{2m_N} = 20.735~\mathrm{MeV\, fm}^2,
\quad
m_N \approx 938.9~\mathrm{MeV}/c^2.
\]
(If the two-body reduced mass is introduced, it is 
\(\mu_{\mathrm{red}}=469.46~\mathrm{MeV}/c^2\), for which 
\(\hbar^2/(2\mu_{\mathrm{red}})\simeq 41.5~\mathrm{MeV\, fm}^2\);  

however, the BHF single-particle spectrum uses the kinetic factor 
\(\hbar^2/(2m_N)=20.735~\mathrm{MeV\, fm}^2\). For clarity, the same kinetic factor is used in the two-body propagator of the Bethe–Goldstone equation within this simplified scheme.)

A momentum cutoff 
\[
\Lambda = 6.0~\mathrm{fm}^{-1}
\]
is imposed.

For the numerical evaluation of momentum integrals, we introduce a momentum-scale parameter \(b = 1.7~\mathrm{fm}\) and perform Gauss–Laguerre quadrature after the change of variables
\(t = k^2/b^2\), so that radial integrals of the form \(\int_0^\infty k^2 f(k)\,dk\) are approximated by a finite sum over Gauss–Laguerre nodes and weights. The sharp regulator \(k\leq\Lambda\) is enforced by multiplying the Yamaguchi form factor with a step function \(\Theta(\Lambda-k)\), i.e. by setting \(g(k)=0\) for \(k>\Lambda\) in all momentum integrals.

Throughout we work in a schematic BHF model (single central S-wave, spin–isospin independent Yamaguchi interaction, fixed pair c.m. momentum \(K=0\)), with schematic spin–isospin averaging (no explicit \((S,T)\) projectors); this is not a full Bethe nuclear-matter BHF calculation with channel decomposition and \(K\)-integration.

We adopt a simplified BHF scheme: 

(i) Only the central S-wave (\(l=0\)) component of the interaction is retained; 

(ii) The interaction is taken as spin–isospin independent; 

(iii) The pair center-of-mass momentum is fixed at \(K=0\) throughout the ladder summation (no averaging over \(K\)); 

(iv) Momentum-space matrix elements are antisymmetrized under particle exchange \((k\leftrightarrow k')\) in \(L=0\) (denoted by the subscript \(A\)), but no explicit antisymmetrization over spin–isospin channels is performed— the degeneracy \(g=4\) enters only through the density relation above and in \(E/A\); this therefore constitutes a schematic spin–isospin–averaged central S-wave treatment; 

(v) The Pauli operator at \(K=0\) is \(Q(k,k')=\Theta(k-k_F)\,\Theta(k'-k_F)\); 

(vi) The starting energy is the continuous-choice value \(\omega=e(k)+e(k')\); 

(vii) The single-particle spectrum is \(e(k)=\hbar^2 k^2/(2m_N)+U(k)\), with \(U(k)\) obtained self-consistently from the same \(G\)-matrix within this S-wave, \(K=0\) truncation; 

(viii) Only two-body forces are included (no three-body forces or rearrangement terms beyond the self-consistent \(U\)); 

(ix) A sharp regulator is applied so that all momentum sums/integrals respect \(k\le \Lambda\) (integrands are set to zero for \(k>\Lambda\)).

Using the BHF \(G\)-matrix and the self-consistent single-particle 
potential under the above assumptions, compute the total energy per particle \(E/A\) (in MeV), accurate to three significant digits. Use

\[ \frac{E}{A} = \frac{3}{5}\,\frac{\hbar^{2}k_{F}^{2}}{2m_{N}} + \frac{1}{2\rho}\!
\int_{|\mathbf k|<k_F}\!\!\frac{d^3k}{(2\pi)^3}
\int_{|\mathbf k'|<k_F}\!\!\frac{d^3k'}{(2\pi)^3}\;
\langle \mathbf k\,\mathbf k' 
\,\lvert\, 
G(\omega=e(k)+e(k')) 
\,\rvert\, 
\mathbf k\,\mathbf k' 
\rangle_{A}.
\]

Answer: \[
19.2
\]

Solution code:
import math
import numpy as np
from numpy.polynomial import laguerre as nplag

# -----------------------------
# Physical and model constants
# -----------------------------
rho = 0.16                 # fm^{-3}
hbar2_over_2m = 20.735     # MeV fm^2 (single-particle convention)
lam = 6000.0               # MeV fm^2, Yamaguchi strength (bare)
beta = 1.5                 # fm^{-1}, Yamaguchi range
Lambda = 6.0               # fm^{-1}, sharp momentum cutoff

# Antisymmetrized L=0, spin–isospin-averaged kernel: <V_A> = (1 - 1/4) V = 3/4 V
lam_A = 0.75 * lam

# Fermi momentum for symmetric nuclear matter (g=4)
kF = (3.0 * math.pi**2 * rho / 2.0)**(1.0 / 3.0)

# -----------------------------
# Gauss–Laguerre momentum mesh
# -----------------------------
b = 1.7                    # fm, HO momentum length
Nq = 80                    # number of Gauss–Laguerre points

# Standard (α = 0) Gauss–Laguerre nodes and weights on [0, ∞) with weight e^{-t}
t_nodes, wL = nplag.laggauss(Nq)

# Mapped momentum nodes
k_grid = b * np.sqrt(t_nodes)       # fm^{-1}

# Radial weights for ∫_0^∞ k^2 f(k) dk
W_radial = 0.5 * b**3 * wL * np.exp(t_nodes) * np.sqrt(t_nodes)

# 3D measure: ∫ d^3k f(k) = (1 / 2π^2) ∫_0^∞ k^2 dk f(k)
w3d = W_radial / (2.0 * math.pi**2)     # weights for ∫ d^3k/(2π)^3 f(k)

# Sharp cutoff implemented via regulator on the form factor
reg = (k_grid <= Lambda).astype(float)

# Yamaguchi form factor with sharp cutoff
gk = reg / (k_grid**2 + beta**2)

# Hole / particle masks in this discrete k-grid
hole_mask = (k_grid < kF - 1e-12)
part_mask = ~hole_mask

# -----------------------------
# Ladder sum stabilizers
# -----------------------------
eta_mev   = 2.0       # small imaginary regulator in denominators (MeV)
alpha_mix = 0.20      # linear mixing for U
tol_mev   = 5e-3      # convergence threshold on max|ΔU| (MeV)
max_iter  = 80        # max number of iterations
dU_cap    = 5.0       # cap per-point update (MeV) for stability

# -----------------------------
# Bethe–Goldstone pieces (continuous choice)
# -----------------------------
def J_omega_continuous(omega, e_spec):
    """
    Continuous choice Pauli-blocked loop:
      J(ω) = ∫_{k>kF} d^3k/(2π)^3 g(k)^2 / (ω - 2 e(k) + iη)
    Implemented with Gauss–Laguerre 3D weights w3d.
    """
    denom = (omega - 2.0 * e_spec) + 1j * eta_mev
    integrand = np.where(part_mask, w3d * gk**2 / denom, 0.0)
    return np.sum(integrand)

def tau_continuous(omega, e_spec):
    """
    Separable τ(ω) = -λ_A / [1 + λ_A J(ω)]
    with continuous-choice J(ω).
    """
    J = J_omega_continuous(omega, e_spec)
    denom = 1.0 + lam_A * J
    mag = abs(denom)
    if mag < 1e-6:
        denom *= (1e-6 / mag)
    return -lam_A / denom

# ---------------------------------
# Self-consistent single-particle potential U(k)
# ---------------------------------
def U_from_G_continuous(e_spec):
    """
    U(k_i) = ∫_{k'<kF} d^3k'/(2π)^3 G(k_i,k'; ω = e(k_i) + e(k'))
    with G(k,k';ω) = g(k) g(k') τ(ω).
    Only S-wave, K=0, spin–isospin averaged.
    """
    Nk = len(k_grid)
    U_new = np.zeros(Nk, dtype=np.float64)

    for i in range(Nk):
        omega_vec = e_spec[i] + e_spec
        tau_vec = np.array([tau_continuous(om, e_spec) for om in omega_vec])
        G_ik = gk[i] * gk * tau_vec         # complex
        integrand = np.where(hole_mask, w3d * G_ik, 0.0)
        U_new[i] = np.sum(integrand).real

    return U_new

def iterate_U_continuous(verbose=True):
    """
    Self-consistent loop for U(k) in continuous choice, using Gauss–Laguerre
    3D quadrature defined above.
    """
    Nk = len(k_grid)
    U = np.zeros(Nk, dtype=np.float64)

    for it in range(1, max_iter + 1):
        e_spec = hbar2_over_2m * k_grid**2 + U
        U_calc = U_from_G_continuous(e_spec)

        dU = U_calc - U
        dU = np.clip(dU, -dU_cap, dU_cap)

        max_diff = float(np.max(np.abs(dU)))
        U = U + alpha_mix * dU

        if max_diff < tol_mev:
            break

    return U

# ---------------------------------
# Potential energy per particle
# ---------------------------------
def E_pot_per_A_continuous(U):
    e_spec = hbar2_over_2m * k_grid**2 + U
    Nk = len(k_grid)

    f_k = np.zeros(Nk, dtype=np.complex128)

    # Inner integral over k' for each k
    for i in range(Nk):
        if not hole_mask[i]:
            continue
        omega_vec = e_spec[i] + e_spec
        tau_vec = np.array([tau_continuous(om, e_spec) for om in omega_vec])
        G_ik = gk[i] * gk * tau_vec
        integrand = np.where(hole_mask, w3d * G_ik, 0.0)
        f_k[i] = np.sum(integrand)

    I = np.sum(np.where(hole_mask, w3d * f_k, 0.0))
    return (0.5 * I.real) / rho

# ---------------------------------
# Main: compute E/A
# ---------------------------------
if __name__ == "__main__":

    E_kin_per_A = (3.0 / 5.0) * hbar2_over_2m * kF**2

    U_converged = iterate_U_continuous(verbose=True)

    E_pot_per_A = E_pot_per_A_continuous(U_converged)
    E_per_A = E_kin_per_A + E_pot_per_A
    print(f"{E_per_A:.3g}")