Transfer inequality T*(c): tr A^2 (configuration with off-line pairs) >= tr phi_c(P_d) (each pair replaced by a double at its real part).
Model: Montgomery-Taylor window eta^2 = cos(sqrt2 u)/Z on [-1/2,1/2], K = Fourier transform of eta^2; phi_c(t) = t^2 - (t-c)_+^2.
All results are numerical (local optimisation), not certified. Python 3 + numpy + scipy.

clip_ceiling.py        T-C: trial-state ceilings of c-clipped arguments, periodic laws of simple points and doubles (doubles interact).
                       usage: python3 clip_ceiling.py 2,2.5,3,3.35,inf 12            -> out/tC.txt
clip_ceiling_noint.py  calibration: doubles credited 4 with no interaction (run from this directory).
near_triple_dom.py     T-NT: lattice + a pile of m coincident points at distance t (one side / both sides); B-functional
                       difference and T*, c = 67/20 and 2.                            -> out/tNT_grid.txt
tstar_robust.py        T-NT2: one pair; starts lattice / coincident / near-triple piles / dense blocks / second pair / random;
                       L-BFGS-B over the 12 nearest real points in [-6.5, 6.5].
                       usage: python3 tstar_robust.py 2.0 0.02,0.05,0.1,0.2,0.5     -> out/tNT2_c2.txt (and 3.35 -> tNT2_c335.txt)
tstar_multipair.py     T-MP: 2-5 pairs, pairs and 8 nearest real points free.      -> out/tMP_c2a.txt, out/tMP_c2b.txt
tstar_quadcheck.py     independent check of the closed-form Gram entries by Gauss-Legendre quadrature of the frame vectors.
                       usage: python3 tstar_quadcheck.py tstar_multipair.py

Closed forms (pair p +- i delta; g, h = cosh/sinh modes; C_d = Re K(t+id), S_d = -Im K(t+id)):
  <v_x, g> = C_delta(x-p), |<v_x, h>| = |S_delta(x-p)|, |sqrt2 g|^2 = kappa+1, |sqrt2 h|^2 = kappa-1, kappa = K(2 i delta);
  two pairs, t = p1-p2: <g1,g2> = (C_{d1+d2}+C_{d1-d2})/2, <h1,h2> = (C_{d1+d2}-C_{d1-d2})/2,
  |<g1,h2>| = |S_{d1+d2}-S_{d1-d2}|/2, |<h1,g2>| = |S_{d1+d2}+S_{d1-d2}|/2.
tstar_kzero.py         targeted family: near-doubles straddling the zeros of K(.-p) (1.057, 2.030, ...), singles at further zeros,
                       then local optimisation of the 16 nearest points.   usage: python3 tstar_kzero.py tstar_multipair.py -> out/tKZ.txt
tstar_random.py        random restarts: 16 free points in [-4.6, 4.6] (uniform, or near the K-zeros with multiplicity 0-2), rest lattice.
                       usage: python3 tstar_random.py tstar_multipair.py DELTA 60 11  -> out/tRND_DELTA.txt
Note: all minima are the lowest values found by local optimisation, not infima.

--- added: single-pair proof route and the multi-pair counterexample ---
Exact identity (checked): T* = tr(P_d - c)_+^2 + sum_b 2(kappa_b^2-1) + sum_b sum_x U_{d_b}(x-p_b) + sum_{b<b'} [U_{d_b+d_b'} + U_{|d_b-d_b'|}](p_b-p_b'),
  U_y = 4(Re K(.+iy)^2 - K^2).
tstar_sdp3.py / tstar_sdp3s.py  SDP majorant for one pair: min 2 tr((I - v0 v0*)Gamma) + |Gamma|_F^2/4  s.t. <v_t,Gamma v_t> + U_delta(t) >= 0 on a t-grid;
                       prints r = value / (2(kappa^2-1)); usage: python3 tstar_sdp3.py 30 40 0.005 0.05,0.1,0.175   (needs cvxpy + Clarabel)
                       outputs out/tSDP3_*.txt (status optimal_inaccurate: numerical, not certified; grid-only constraint)
pairpair_check.py      pair-pair bracket with the single-pair Gammas (needs tstar_sdp3s.py outputs)
tstar_mp2.py, tstar_mpk.py  multi-pair blocks inside a lattice of real doubles (counterexample: T* < 0 at delta 0.25, k >= 4)
cex_mp2.py             recomputes the k=4 minimiser and checks T* by Gauss-Legendre quadrature (-0.0226)
tstar_k1dl.py          one pair inside a lattice of real doubles (positive)
