#!/usr/bin/env python3
"""Zero side of the 2T aligned pure part.  Usage: python3 run.py b.a|a.a   (plain python3 + numpy/scipy/mpmath)

Explicit formula for an Artin L-function pi (dim d, conductor N, Gamma_R(s+kappa_j)), general (non-self-dual) form
[known: Weil 1952; Iwaniec-Kowalski Thm 5.12], test function h entire, decaying, with Fourier transform
 w(x) = (1/2pi) int h(r) e^{-irx} dr  (not nec. even):
   sum_{rho in zeros(L(pi))} h(gamma_rho)  [rho = 1/2 + i gamma]
     = pole terms + (1/2pi) int h(r)[log N + sum_j Re psi((1/2+kappa_j+ir)/2) - d log pi] dr      (arch, even part of h only)
       - sum_n [Lam_pi(n) w(log n) + conj(Lam_pi(n)) w(-log n)] / sqrt(n).
 even h:  zeros(pi) U zeros(dual) both counted: prime side -2 sum Re Lam_pi(n) w(log n)/sqrt n.
 odd  h=iH: prime side -2 sum Im Lam_pi(n) W(log n)/sqrt n   (H(r)=int W(x) sin(rx) dx) and arch part vanishes.
Zero side from PARI lfunzeros: positive zeros of pi, positive zeros of dual(pi) (= conj of negative zeros of pi).
Code A: mpmath (30 digits), quaternion Frobenius from idealfrobenius classes (aligned convention).
Code B: numpy/scipy double, Lambda from PARI a_n.
"""
import json, math, sys, time, cmath, itertools
import numpy as np, mpmath as mp
from scipy import integrate, special
from datetime import datetime
from zoneinfo import ZoneInfo
mp.mp.dps = 30
KEY = sys.argv[1] if len(sys.argv) > 1 else 'b.a'
LAB = {'b.a': '2.26569.24t7.b.a', 'a.a': '2.26569.24t7.a.a'}[KEY]
D = json.load(open('../tetra1112/pari-data.json'))[LAB]
Zj = json.load(open(f'zeros-{KEY}.json'))
HCUT = Zj['H']; NMAX = 20000
Y = cmath.exp(2j*math.pi/3)
def ev(s): return complex(eval(s.replace('^', '**'), {'y': Y}))
tab = [[ev(x) for x in row] for row in D['chartable']]
chars = D['chars']
dims = [c['dim'] for c in chars]
# --- class / character identification (as tetra1112/analyze.py) ---
def qm(a, b):
    a0,a1,a2,a3 = a; b0,b1,b2,b3 = b
    return (a0*b0-a1*b1-a2*b2-a3*b3, a0*b1+a1*b0+a2*b3-a3*b2, a0*b2-a1*b3+a2*b0+a3*b1, a0*b3+a1*b2-a2*b1+a3*b0)
def key(q): return str(tuple(int(round(2*x)) for x in q))
cq = D['class_of_quat']
g6 = (.5, .5, .5, .5)
def qpow(a, k):
    r = (1., 0, 0, 0)
    for _ in range(k): r = qm(r, a)
    return r
def cls(q): return cq[key(q)]
def chi(c, q): return tab[cls(q)][c]
real2 = [c for c in range(7) if dims[c] == 2 and all(abs(tab[r][c].imag) < 1e-12 for r in range(7))]; RHO = real2[0]
PSI3 = dims.index(3)
OM = [c for c in range(7) if dims[c] == 1 and abs(chi(c, g6) - Y) < 1e-12][0]
OMB = [c for c in range(7) if dims[c] == 1 and abs(chi(c, g6) - Y.conjugate()) < 1e-12][0]
TRIV = [c for c in range(7) if dims[c] == 1 and c not in (OM, OMB)][0]
RW = [c for c in range(7) if dims[c] == 2 and c != RHO and all(abs(tab[r][c] - tab[r][RHO]*tab[r][OM]) < 1e-12 for r in range(7))][0]
RWB = [c for c in range(7) if dims[c] == 2 and c not in (RHO, RW)][0]
NAME = {RHO: 'rho', RW: 'rho⊗w', RWB: 'rho⊗wbar', OM: 'w', OMB: 'wbar', PSI3: 'psi3', TRIV: 'zeta'}
# aligned representatives: six powers of g6 (one per class), u = i for the order-4 class
REP = {}
for k in range(6): REP[cls(qpow(g6, k))] = qpow(g6, k)
c4 = cls((0., 1., 0., 0.)); REP[c4] = (0., 1., 0., 0.)
assert len(REP) == 7
NH = np.array([0, 1, 1, 1])/math.sqrt(3)
def primes_upto(n):
    s = bytearray([1])*(n+1); s[0]=s[1]=0
    for i in range(2, int(n**.5)+1):
        if s[i]: s[i*i::i] = bytearray(len(s[i*i::i]))
    return [i for i in range(n+1) if s[i]]
PR = primes_upto(NMAX); RAM = set(D['ramified'])
ZP = {c: np.array(Zj['chars'][str(c+1)]['zeros_pos']) for c in range(7)}
ZD = {c: np.array(Zj['chars'][str(c+1)]['zeros_dual_pos']) for c in range(7)}
M0 = {c: Zj['chars'][str(c+1)].get('order0', 0) for c in range(7)}
# central zero is listed as 0.0 inside ZP/ZD when order0>0: strip and treat separately
for c in range(7):
    if M0[c]:
        assert ZP[c][0] == 0.0 and ZD[c][0] == 0.0
        ZP[c] = ZP[c][1:]; ZD[c] = ZD[c][1:]
# --- Lambda from a_n (method B), complex; includes ramified primes ---
def lam_from_an(c):
    a = [complex(*x) for x in chars[c]['an']]
    Lam = {}
    for p in PR:
        q = p; k = 1; prev = []
        while q <= NMAX:
            s = a[q-1]*k*math.log(p) - sum(prev[j-1]*a[p**(k-j)-1] for j in range(1, k))
            prev.append(s); Lam[q] = (p, k, s); q *= p; k += 1
    return Lam
LAM = {c: lam_from_an(c) for c in range(7)}
DEG = {c: dims[c] for c in range(7)}
# --- quaternion prime data (method A): per unramified p -> aligned g_p ---
GP = {}
for ps, v in D['frob'].items():
    GP[int(ps)] = REP[v['frobs'][0]['cls']]
# ---------------- test-function families ----------------
def g0m(T, x): return T/(2*mp.sqrt(mp.pi))*mp.exp(-(T*x)**2/4)
def g0f(T, x): return T/(2*math.sqrt(math.pi))*math.exp(-(T*x)**2/4)
KERF = 8.0
def Fint(a, r, K, mod):
    f = lambda kap: r*mod.exp(-r*r/(4*(a+kap*kap)))/(a+kap*kap)**1.5
    return f
class Fam:
    """kind 'E' even: h=exp(-(r/T)^2)cos(x0 r), w=(g0(x-x0)+g0(x+x0))/2.
       kind 'S' odd:  h=i*H, H=exp(-(r/T)^2) sin(x0 r),  W=(g0(x-x0)-g0(x+x0))/2.
       kind 'G' odd:  W=g0(x) erf(K x) (plain Gaussian weight at x>0), H=T/(2 sqrt pi) * int_0^K r e^{-r^2/(4(a+k^2))}/(a+k^2)^{3/2} dk, a=T^2/4."""
    def __init__(s, kind, T, x0=0.0): s.kind, s.T, s.x0 = kind, T, x0
    def h_m(s, r):       # mpmath; for odd returns H (real)
        T, x0 = s.T, s.x0
        if s.kind == 'E': return mp.exp(-(r/T)**2)*mp.cos(x0*r)
        if s.kind == 'S': return mp.exp(-(r/T)**2)*mp.sin(x0*r)
        a = mp.mpf(T)**2/4
        F = mp.quad(lambda k: r*mp.exp(-r*r/(4*(a+k*k)))/(a+k*k)**1.5, [0, KERF/2, KERF])
        return T/(2*mp.sqrt(mp.pi))*F
    def h_f(s, r):
        T, x0 = s.T, s.x0
        if s.kind == 'E': return math.exp(-(r/T)**2)*math.cos(x0*r)
        if s.kind == 'S': return math.exp(-(r/T)**2)*math.sin(x0*r)
        a = T*T/4
        F, _ = integrate.quad(lambda k: r*math.exp(-r*r/(4*(a+k*k)))/(a+k*k)**1.5, 0, KERF, epsabs=1e-15, epsrel=1e-13)
        return T/(2*math.sqrt(math.pi))*F
    def w_m(s, x):
        T, x0 = s.T, s.x0
        if s.kind == 'E': return (g0m(T, x-x0)+g0m(T, x+x0))/2
        if s.kind == 'S': return (g0m(T, x-x0)-g0m(T, x+x0))/2
        return g0m(T, x)*mp.erf(KERF*x)
    def w_f(s, x):
        T, x0 = s.T, s.x0
        if s.kind == 'E': return (g0f(T, x-x0)+g0f(T, x+x0))/2
        if s.kind == 'S': return (g0f(T, x-x0)-g0f(T, x+x0))/2
        return g0f(T, x)*math.erf(KERF*x)
    @property
    def odd(s): return s.kind != 'E'
    def env(s, r): return math.exp(-(r/s.T)**2)   # |h| envelope for budgets (G: heuristic, see note)
# ---------------- archimedean + poles ----------------
def arch_m(fam, c):
    if fam.odd: return mp.mpf(0)
    N = chars[c]['conductor']; kap = chars[c]['Vga']
    f = lambda r: fam.h_m(r)*(mp.log(N) + mp.fsum(mp.re(mp.digamma((mp.mpf(1)/2+kj+1j*r)/2)) - mp.log(mp.pi) for kj in kap))
    T = fam.T
    pts = [0] + [T*m for m in (0.5, 1, 1.5, 2, 3, 4, 6, 8, 12)] + [mp.inf]
    if fam.x0:  # oscillation: add fine subdivision
        pts = sorted(set([0] + [mp.mpf(j)*mp.pi/ max(fam.x0, 1) for j in range(1, int(12*T*max(fam.x0, 1)/mp.pi)+1)] + [mp.inf]))
        pts = [p for p in pts if p == 0 or p == mp.inf or p <= 12*T]+[mp.inf]
        pts = sorted(set(pts), key=lambda z: float(z))
    return 2*mp.quad(f, pts)/(2*mp.pi)
def arch_f(fam, c):
    if fam.odd: return 0.0
    N = chars[c]['conductor']; kap = chars[c]['Vga']
    f = lambda r: fam.h_f(r)*(math.log(N) + sum(special.digamma((0.5+kj+1j*r)/2).real - math.log(math.pi) for kj in kap))
    v = 0.0; edges = np.linspace(0, 12*fam.T, int(12*fam.T*max(fam.x0, 1)/2)+2)
    for lo, hi in zip(edges[:-1], edges[1:]):
        v += integrate.quad(f, lo, hi, epsabs=1e-15, epsrel=1e-13, limit=200)[0]
    return 2*v/(2*math.pi)
def pole_m(fam, c):   # zeta only (the trivial character): h(i/2)+h(-i/2)  (even h)
    if c != TRIV or fam.odd: return mp.mpf(0)
    T, x0 = fam.T, fam.x0
    z = 1j/2
    return 2*mp.re(mp.exp(-(z/T)**2)*mp.cos(x0*z))
def pole_f(fam, c):
    if c != TRIV or fam.odd: return 0.0
    T, x0 = fam.T, fam.x0
    return 2*(cmath.exp(-((0.5j)/T)**2)*cmath.cos(x0*0.5j)).real
# ---------------- zero sums ----------------
def zero_m(fam, c):
    """even: m0 h(0) + sum_pos(pi) h + sum_pos(dual) h ; odd: sum_pos(pi) H - sum_pos(dual) H"""
    if fam.odd:
        return mp.fsum(fam.h_m(mp.mpf(z)) for z in ZP[c]) - mp.fsum(fam.h_m(mp.mpf(z)) for z in ZD[c])
    m0 = M0[c]
    return m0*fam.h_m(mp.mpf(0)) + mp.fsum(fam.h_m(mp.mpf(z)) for z in ZP[c]) + mp.fsum(fam.h_m(mp.mpf(z)) for z in ZD[c])
def zero_f(fam, c):
    if fam.odd:
        return sum(fam.h_f(z) for z in ZP[c]) - sum(fam.h_f(z) for z in ZD[c])
    return M0[c]*fam.h_f(0.0) + sum(fam.h_f(z) for z in ZP[c]) + sum(fam.h_f(z) for z in ZD[c])
# ---------------- prime sides ----------------
def prime_lam_m(fam, c):
    """B-side in mpmath weights: even: -2 sum Re Lam w/sqrt ; odd: -2 sum Im Lam W/sqrt (all p incl. ramified)"""
    tot = mp.mpf(0)
    for n, (p, k, s) in LAM[c].items():
        w = fam.w_m(mp.log(n)) / mp.sqrt(n)
        v = s.imag if fam.odd else s.real
        tot += -2*mp.mpf(v)*w
    return tot
def prime_lam_f(fam, c):
    tot = 0.0
    for n, (p, k, s) in LAM[c].items():
        w = fam.w_f(math.log(n))/math.sqrt(n)
        tot += -2*(s.imag if fam.odd else s.real)*w
    return tot
def quat_parts_m(fam):
    """Method A: from the actual aligned quaternion g_p (unramified p only).
       returns real = -2 sum Re(g^k) log p w/p^{k/2}; nsum = same with component of Im(g^k) along n-hat;
       usum = component along u = i (class 4a only, prime-power exact incl. eps_k)."""
    re = mp.mpf(0); ns = mp.mpf(0); us = mp.mpf(0)
    for p, g in GP.items():
        q = (1., 0, 0, 0); pk = 1; lg = mp.log(p)
        for k in range(1, 40):
            q = qm(q, g); pk *= p
            if pk > NMAX: break
            wt = -2*lg*fam.w_m(k*lg)/mp.sqrt(pk)
            re += wt*q[0]
            if cls(g) == c4: us += wt*q[1]
            else: ns += wt*(q[1]*NH[1]+q[2]*NH[2]+q[3]*NH[3])
    return re, ns, us
def quat_parts_f(fam):
    re = 0.0; ns = 0.0; us = 0.0
    for p, g in GP.items():
        q = (1., 0, 0, 0); pk = 1; lg = math.log(p)
        for k in range(1, 40):
            q = qm(q, g); pk *= p
            if pk > NMAX: break
            wt = -2*lg*fam.w_f(k*lg)/math.sqrt(pk)
            re += wt*q[0]
            if cls(g) == c4: us += wt*q[1]
            else: ns += wt*(q[1]*NH[1]+q[2]*NH[2]+q[3]*NH[3])
    return re, ns, us
# ---------------- error budget (heuristic zero tail) ----------------
def tail_bound(fam, c, E=10.0):
    """[heuristic] zeros above HCUT (both signs, pi and dual together = 2 families of positive zeros):
       |sum| <= 2*( env(HCUT)*E + int_HCUT^inf env(t) rho(t) dt ), rho(t)=(1/2pi)(log N + d log(t/2pi)) per family; 
       E = margin on the zero count (not a proved explicit N(T) bound)."""
    N = chars[c]['conductor']; d = dims[c]; T = fam.T
    env = (lambda t: mp.exp(-(t/T)**2)) if fam.kind != 'G' else (lambda t: mp.mpf('0.6')*mp.exp(-t*t/(4*(mp.mpf(T)**2/4+KERF**2))))  # G: |H|<=~0.6 e^{-r^2/(4(a+K^2))} (checked on a grid)
    rho = lambda t: (mp.log(N) + d*mp.log(t/(2*mp.pi)))/(2*mp.pi)
    b = env(HCUT)*E + mp.quad(lambda t: env(t)*rho(t), [HCUT, HCUT+5*T, mp.inf])
    if fam.odd: # |H| <= envelope*(1+small) for S; for G, H(r) envelope is larger (1/r tail) -> use 1/(r) bound ~ generous
        pass
    return float(2*b)
def prime_tail(fam, d):
    """[bound, crude] truncation of the prime side at n<=NMAX: 2 d int_{log NMAX}^inf x |w(x)| e^{x/2} dx, |Lam(n)|<=d log n, |w|<=envelope"""
    T, x0 = fam.T, fam.x0
    env = (lambda x: (g0m(T, x-x0)+g0m(T, x+x0))/2) if fam.kind in 'ES' else (lambda x: g0m(T, x))
    return float(2*d*mp.quad(lambda x: x*env(x)*mp.exp(x/2), [mp.log(NMAX), mp.log(NMAX)+2, mp.log(NMAX)+8, mp.inf]))
def tail_G_bound(T, c, E=10.0):
    """For the sgn*Gaussian family |H(r)| <= min(1, C/r) * exp(-r^2/(4 (a+K^2)))-like; we bound |H(r)| by
       numerical sup over r>=HCUT of |H| from the closed form (checked on a grid) times the zero count above HCUT up to 3x height."""
    return None

def main():
    t0 = time.time()
    res = dict(generated=datetime.now(ZoneInfo('America/Los_Angeles')).isoformat(), field=LAB, hcut=HCUT, nmax=NMAX, kerf=KERF,
               labels='[project] numerical verification of [known] theorems; double-computed (mpmath 30 digits vs numpy/scipy doubles); float, not interval',
               zero_counts={NAME[c]: dict(pos=len(ZP[c]), dual_pos=len(ZD[c]), m0=M0[c]) for c in range(7)}, rows=[])
    fams = []
    for T in [1.0, 1.5, 2, 3, 5, 8, 12, 16, 20]:
        fams.append(Fam('E', T, 0.0))
        if T <= 8: fams.append(Fam('G', T))
    for x0 in [1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 8.5]:
        fams.append(Fam('E', 8.0, x0)); fams.append(Fam('S', 8.0, x0))
    for T in [2, 3, 5]:
        for x0 in [1.0, 2.0, 3.0]:
            fams.append(Fam('S', float(T), x0))
    # Lambda cross-check: B-Lambda vs quaternion powers (character decomposition)
    for fam in fams:
        t1 = time.time()
        row = dict(kind=fam.kind, T=fam.T, x0=fam.x0)
        ZA = {c: zero_m(fam, c) for c in range(7) if (fam.odd and c in (RW, RWB)) or (not fam.odd)}
        ZB = {c: zero_f(fam, c) for c in ZA}
        AA = {c: arch_m(fam, c) + pole_m(fam, c) for c in ZA}
        AB = {c: arch_f(fam, c) + pole_f(fam, c) for c in ZA}
        PLA = {c: prime_lam_m(fam, c) for c in ZA}; PLB = {c: prime_lam_f(fam, c) for c in ZA}
        reA, nsA, usA = quat_parts_m(fam); reB, nsB, usB = quat_parts_f(fam)
        row['per_L'] = {NAME[c]: dict(zero=float(ZA[c]), arch_pole=float(AA[c]), prime=float(PLA[c]), diff_A=float(ZA[c]-AA[c]-PLA[c]),
                                       diff_B=ZB[c]-AB[c]-PLB[c], zero_A_minus_B=float(ZA[c])-ZB[c]) for c in ZA}
        if not fam.odd:
            # real part (control): Re quaternion prime sum = 1/2 * prime side of rho
            row['real'] = dict(quat_re=float(reA), half_rho_prime=float(PLA[RHO]/2), diff=float(reA-PLA[RHO]/2),
                               rho_zero_side=float(ZA[RHO]), central_share=float(M0[RHO]*fam.h_m(mp.mpf(0))/ZA[RHO]),
                               rho_resid_with_central=float(ZA[RHO]-AA[RHO]-PLA[RHO]),
                               rho_resid_without_central=float(ZA[RHO]-M0[RHO]*fam.h_m(mp.mpf(0))-AA[RHO]-PLA[RHO]),
                               zero_side_half_rho=float(ZA[RHO]/2), arch_half_rho=float(AA[RHO]/2),
                               budget_tail_rho=tail_bound(fam, RHO), budget_prime_tail_rho=prime_tail(fam, 2))
            # u-direction: U_quat = zero-side(lin) + Delta
            lin_zero = (ZA[TRIV]-AA[TRIV]) + (ZA[OM]-AA[OM]) + (ZA[OMB]-AA[OMB]) - (ZA[PSI3]-AA[PSI3])
            # careful: zero_m for omega counts zeros of w and of wbar (both), same for wbar -> each equals full zeros(w)+zeros(wbar)
            # Lambda-side: -2 sum Re(Lam_w) w  for even h; the even formula for omega gives sum over zeros(w) U zeros(wbar)... see note: halve
            ulin_zero = ((ZA[TRIV]-AA[TRIV]) + (ZA[OM]-AA[OM]) - (ZA[PSI3]-AA[PSI3]))/2*0  # placeholder replaced below
            # exact: U_lin = 1/4 sum_c eps_c * [ -2 sum Re(Lam_c) w/sqrt n ] for c in (zeta, w, wbar, psi3), and
            # Z_c - A_c = -2 sum Re(Lam_c) w/sqrt n  holds for each (even formula, Lam real part), so:
            ulin_zero = ((ZA[TRIV]-AA[TRIV]) + (ZA[OM]-AA[OM]) + (ZA[OMB]-AA[OMB]) - (ZA[PSI3]-AA[PSI3]))/4
            ulin_prime = (PLA[TRIV] + PLA[OM] + PLA[OMB] - PLA[PSI3])/4
            row['u'] = dict(quat=float(usA), quat_B=usB, lin_zero_side=float(ulin_zero), lin_prime_side=float(ulin_prime),
                            delta_primepower=float(usA-ulin_prime), resid_A=float(usA-(ulin_zero+(usA-ulin_prime))),
                            codeA_B_quat=float(usA)-usB,
                            contrib_zero_minus_arch={NAME[c]: float(s*(ZA[c]-AA[c])/4) for c, s in ((TRIV, 1), (OM, 1), (OMB, 1), (PSI3, -1))},
                            budget_tail=sum(tail_bound(fam, c) for c in (TRIV, OM, OMB, PSI3))/4, budget_prime_tail=prime_tail(fam, 6)/4)
        else:
            # n-direction: N_quat(unram) + ramified-163 term = zero side(rho⊗w);  Lam_{rho⊗wbar} = conj Lam_{rho⊗w}
            ram = -2*sum(float(s.imag)*fam.w_f(math.log(n))/math.sqrt(n) for n, (p, k, s) in LAM[RW].items() if p in RAM)
            ramA = mp.fsum(-2*mp.mpf(s.imag)*fam.w_m(mp.log(n))/mp.sqrt(n) for n, (p, k, s) in LAM[RW].items() if p in RAM)
            row['n'] = dict(quat=float(nsA), quat_B=nsB, ram163=float(ramA), prime_lam_total=float(PLA[RW]),
                            quat_plus_ram_minus_lam=float(nsA+ramA-PLA[RW]),
                            zero_side=float(ZA[RW]), resid_A=float(ZA[RW]-nsA-ramA), resid_B=ZB[RW]-nsB-ram,
                            zero_pos_part=float(mp.fsum(fam.h_m(mp.mpf(z)) for z in ZP[RW])),
                            zero_neg_part=float(-mp.fsum(fam.h_m(mp.mpf(z)) for z in ZD[RW])),
                            budget_tail=tail_bound(fam, RW), budget_prime_tail=prime_tail(fam, 2))
            # conj twist: coefficient bookkeeping  -(i/2)n * [pi] + (i/2) n * [pibar] -> real
            ZW, ZWB = float(ZA[RW]), float(ZA[RWB])
            row['n']['dual_zero_side'] = ZWB     # = -ZW (odd test function): rho⊗wbar is the mirror image
            row['n']['combined_check'] = float(0.5*ZW - 0.5*ZWB - ZW)  # n-comp = -(i/2)(iH_pi)+(i/2)(iH_pibar) = (H_pi-H_pibar)/2 = H_pi since H_pibar=-H_pi
        row['secs'] = round(time.time()-t1, 1)
        res['rows'].append(row)
        n_ = row.get('n'); u_ = row.get('u'); r_ = row.get('real')
        print(f"{fam.kind} T={fam.T} x0={fam.x0}: " +
              (f"real diff {r_['diff']:.1e} rhoRes {r_['rho_resid_with_central']:+.1e}(noC {r_['rho_resid_without_central']:+.1e}) uQ={u_['quat']:+.8f} uResA={u_['resid_A']:+.1e} delta={u_['delta_primepower']:+.2e} " if r_ else '') +
              (f"nQ={n_['quat']:+.9f} ram={n_['ram163']:+.2e} Z={n_['zero_side']:+.9f} resA={n_['resid_A']:+.2e} resB={n_['resid_B']:+.2e} budget={n_['budget_tail']+n_['budget_prime_tail']:.1e}" if n_ else '') +
              f"  [{row['secs']}s]", flush=True)
    res['elapsed_seconds'] = time.time()-t0
    json.dump(res, open(f'results-{KEY}.json', 'w'), indent=1)
if __name__ == '__main__': main()
