V2.192: Precision Delta Extraction — The Log-Coefficient Bottleneck

Status: COMPLETED — alpha verified to 0.01%, delta limited to ~10% by signal hierarchy

Motivation

The formula Omega_Lambda = |delta|/(6*alpha) has two inputs: the area-law coefficient alpha and the log coefficient delta. V2.185 verified alpha to 0.009% on the lattice via Richardson extrapolation. But delta has only been verified to ~1% (V2.187). Since delta enters the prediction equally with alpha, it is the bottleneck limiting the overall lattice verification.

This experiment attempts to push delta precision using the second-difference method d^2S(n) and reveals a fundamental signal-hierarchy limitation.

Method

The entanglement entropy of a massless scalar on a sphere has:

S(n, C) = alpha(C) * 4*pi*n^2 + delta * ln(n) + gamma + beta/n + O(1/n^2)

The second difference at fixed angular cutoff-per-radius C (l_max = C*n):

d^2S(n) = S(n+1) - 2*S(n) + S(n-1)
        = 8*pi*alpha(C) + delta*ln[1 - 1/n^2] + beta*2/[n(n^2-1)] + O(1/n^4)

At each C, we compute d^2S at multiple n values, fit to extract alpha and delta simultaneously, then Richardson-extrapolate alpha(C) and delta(C) to C -> infinity.

Key insight: Using EXACT second-difference basis functions (ln[1-1/n^2] and 2/[n(n^2-1)]) rather than Taylor approximations (1/n^2 and 2/n^3) is important to avoid near-degeneracy in the fit.

Key Results

1. Alpha Confirmed to 0.01%

Richardson extrapolation of alpha(C) from C=10..50 gives:

alpha_lattice = 0.023510  (error = +0.011%)
alpha_exact   = 0.023508  [= 1/(24*sqrt(pi))]

This independently confirms V2.185’s result. The Richardson sequence converges monotonically:

k	C_min	C_max	alpha	error%
2	40	50	0.023551	+0.185
3	30	50	0.023516	+0.035
4	25	50	0.023512	+0.017
7	10	50	0.023510	+0.011

2. Delta Extraction Limited to ~10-15%

The best delta extraction achieves ~10% error:

delta_lattice = -0.0127  (error ≈ +14%)
delta_exact   = -0.01111  [= -1/90]

The error is SYSTEMATIC, not statistical. It persists across all C values and n ranges tested, varying between +7% and +47% depending on the n range used for fitting.

3. The Signal Hierarchy Problem

Why alpha converges 1000x faster than delta:

At n=20, C=20:

• d^2S ≈ 0.5854 (dominated by the area term 8pialpha)
• delta contribution: delta * ln(1-1/400) ≈ 0.0000028 (0.005% of d^2S)
• beta contribution: 2beta/[20399] ≈ 0.0000014 (0.002% of d^2S)

The log coefficient contributes only 5 parts per million to d^2S. Extracting delta requires measuring d^2S to ~6 significant figures AND correctly separating the 1/n^2 and 1/n^3 corrections, which are nearly degenerate at n=10..30.

By contrast, alpha dominates d^2S at leading order, so even 3-figure precision on d^2S gives alpha to 0.1%.

4. Sensitivity to Fit Range

The extracted delta depends strongly on which n values are used:

n range	n_pts	alpha error	delta error
[10..20]	5	-0.93%	+7.2%
[10..25]	6	-0.93%	+10.8%
[10..30]	7	-0.93%	+14.6%
[12..30]	6	-0.93%	+21.7%
[15..35]	6	-0.93%	+47.3%

Alpha is stable to 6 significant figures regardless of n range. Delta varies by 40 percentage points. This instability is the hallmark of an ill-conditioned extraction.

5. What Would Fix It

To reach 1% delta precision, we need n >> 50 so that:

• delta/n^2 >> beta/n^3 (the corrections separate cleanly)
• Enough significant figures on d^2S to see the ~10^-7 residual

This requires C*n_max ~ 5000+, meaning ~5000 eigendecompositions per S(n) computation. With current infrastructure, this would take ~10 hours per C value on a laptop. A cluster computation pushing to n=200, C=100 could achieve ~1% delta precision.

6. R = |delta|/(6*alpha) from Lattice

Even at ~10% delta precision, the ratio is meaningful:

R_lattice = |delta_lattice| / (6 * alpha_lattice) ≈ 0.090
R_exact   = |delta_exact|   / (6 * alpha_exact)   = 0.0788
R_lattice / R_exact ≈ 1.14  (14% high)

Note: R = 0.079 is the SINGLE-SCALAR ratio, not the SM ratio R_SM = 0.685. The SM ratio involves the field-content-weighted sum over all SM fields.

Implications for the Research Program

1. Alpha is lattice-verified to 0.01% — case closed

The area-law coefficient alpha_s = 1/(24*sqrt(pi)) is verified to 0.01% by two independent experiments (V2.185 and this work). This input to the Omega_Lambda formula is settled.

2. Delta verification requires order-of-magnitude more computing

The log coefficient delta_s = -1/90 is verified to ~10%. Reaching 1% requires either:

• Much larger lattices (n up to 200, l_max up to 20,000)
• Alternative methods (Renyi entropy, mutual information, heat-kernel approaches)
• Analytical improvements (e.g., fitting using known functional forms)

3. The analytic value of delta is protected by topology

Unlike alpha, which must be computed on the lattice, delta = -4*a is fixed by the Wess-Zumino consistency condition (the conformal anomaly is determined by representation theory). The lattice verification of delta is a consistency check, not a derivation. The exact value a_scalar = 1/360 (hence delta = -1/90) is as rigorous as any result in QFT.

4. The Omega_Lambda prediction does NOT require lattice delta

The formula Omega_Lambda = |delta_total|/(6*alpha_total) uses:

• delta_total from EXACT anomaly coefficients (Wess-Zumino)
• alpha_total from the CONJECTURED alpha_s = 1/(24*sqrt(pi))

Only alpha needs lattice verification. Delta is analytically exact. The 0.01% alpha verification already provides a 0.01% check on the formula’s input.

Honest Assessment

Strengths:

• Alpha independently confirmed to 0.01% (matching V2.185)
• Identified and quantified the signal-hierarchy problem: delta is 10,000x harder than alpha
• Used exact second-difference basis functions (a methodological improvement)
• Clear roadmap for higher precision (need n ~ 200)

Limitations:

• Delta only extracted to ~10% — not the “precision frontier” originally hoped for
• Result is sensitive to fit range (a sign of ill-conditioning)
• Richardson extrapolation doesn’t help delta (the error is in n-dependence, not C-dependence)
• Current lattice infrastructure limits n_max to ~30-40 for reasonable runtime

The bottom line: Delta extraction from the lattice is limited to ~10% at accessible subsystem sizes, 1000x worse than alpha. This is not a failure of the method but a fundamental consequence of the signal hierarchy: the log term is 10,000x smaller than the area term. However, the analytic value delta = -1/90 is protected by Wess-Zumino consistency and does not need lattice verification. The formula’s precision is limited by alpha (0.01%), not delta.

Files

• src/delta_extraction.py — Radial chain, entropy, d^2S fitting, Richardson extrapolation
• tests/test_delta.py — 8 tests (all passing)
• run_experiment.py — 6-phase analysis
• results/summary.json — Numerical results