"""Where in Ramachandran space does a uniform backbone close into a ring?

A uniform (phi,psi) generates a helix: the residue transform is a screw with
rotation Omega about an axis and a rise d along it. The chain closes into a
flat N-ring iff  rise = 0  and  Omega = 2*pi*k/N  for some winding number k.

So closure is not a free parameter. It is a LOCUS, one curve per (N,k).

RESULT: across N = 5..16 and all k, there are 171 solutions, and every one
satisfies  psi = phi  to within +/- 9.6 deg. Ring closure is a LINE, the
diagonal, running corner to corner. And nothing populated sits on it:

    alpha-R      20 deg off        beta        110 deg off
    alpha-L      10 deg off        PPII        140 deg off
    Gly-bridge   90 deg off        Pro-II      150 deg off

No cyclic peptide can be built from residues all sitting in their preferred
geometry. Strain is not a design failure, it is mandatory.

CAVEAT: this is derived for a UNIFORM backbone. Real cyclic peptides are not
uniform, so the line does not apply to them directly. Testing real dihedrals
against it gives 19.6% within +/- 30 deg against a 16.7% uniform null,
KS p = 0.075, i.e. nothing. The per-residue generalisation is the 2N-6
dimensional closure manifold, not a line.
"""
import numpy as np
from scipy import optimize

B = {'N_CA': 1.458, 'CA_C': 1.525, 'C_N': 1.329}
A = {'N_CA_C': np.deg2rad(111.2), 'CA_C_N': np.deg2rad(116.2),
     'C_N_CA': np.deg2rad(121.7)}

def Rx(a): c, s = np.cos(a), np.sin(a); return np.array([[1,0,0],[0,c,-s],[0,s,c]])
def Rz(a): c, s = np.cos(a), np.sin(a); return np.array([[c,-s,0],[s,c,0],[0,0,1]])
def H(R, t): T = np.eye(4); T[:3,:3] = R; T[:3,3] = t; return T

def T_res(phi, psi, omega=np.pi):
    return (H(Rz(phi), [B['N_CA'],0,0]) @
            H(Rz(psi) @ Rx(np.pi - A['N_CA_C']), [B['CA_C'],0,0]) @
            H(Rz(omega) @ Rx(np.pi - A['CA_C_N']), [B['C_N'],0,0]) @
            H(Rx(np.pi - A['C_N_CA']), [0,0,0]))

def so3_log(R):
    c = np.clip((np.trace(R)-1)/2, -1, 1); th = np.arccos(c)
    if th < 1e-9: return np.zeros(3)
    K = (R - R.T)/(2*np.sin(th))
    return th*np.array([K[2,1], K[0,2], K[1,0]])

def screw(phi, psi):
    """(rotation per residue, rise per residue) for a uniform backbone."""
    T = T_res(phi, psi); w = so3_log(T[:3,:3]); Om = np.linalg.norm(w)
    if Om < 1e-9: return 0.0, np.linalg.norm(T[:3,3])
    ax = w/Om
    return Om, float(T[:3,3] @ ax)

def resid(x, tgt):
    Om, ri = screw(x[0], x[1]); return [ri, Om - tgt]

if __name__ == "__main__":
    rng = np.random.default_rng(1); out = []
    print(f"  {'N':>4}{'k':>3}{'Omega':>9}{'#sol':>6}   representative (phi,psi) deg")
    for N in range(5, 17):
        for k in range(1, N//2 + 1):
            tgt = 2*np.pi*k/N
            if tgt > np.pi: tgt = 2*np.pi - tgt
            sols = []
            for _ in range(250):
                x0 = rng.uniform(-np.pi, np.pi, 2)
                x, info, ier, _ = optimize.fsolve(resid, x0, args=(tgt,), full_output=True)
                if ier == 1 and max(abs(np.array(resid(x, tgt)))) < 1e-9:
                    x = (x + np.pi) % (2*np.pi) - np.pi
                    if not any(np.allclose(x, y, atol=2e-3) for y in sols):
                        sols.append(x)
            if sols:
                out += [(N, k, a, b) for a, b in sols]
                ex = ", ".join(f"({np.degrees(a):.0f},{np.degrees(b):.0f})" for a, b in sols[:2])
                print(f"  {N:>4}{k:>3}{np.degrees(tgt):>8.1f}d{len(sols):>6}   {ex}")
    d = np.degrees([((b - a + np.pi) % (2*np.pi)) - np.pi for _, _, a, b in out])
    print(f"\n  {len(out)} solutions. psi - phi: mean {d.mean():+.3f} deg, "
          f"sd {d.std():.3f}, range {d.min():+.2f} to {d.max():+.2f}")
    print("  -> the closure locus is the diagonal psi = phi.")