PythagorasGoal/scripts/research/r0703_vrpimp_structgrid.py

"""R0703 VRPIMP-STRUCTGRID — griglia ONESTA di struttura short-vol vs VRP01 canonico.

FILONE 1 (2026-07-03). L'audit ALB-A (r0702_alb_structure) ha testato UNA cella a priori
(z=2.0σ, ali +1σ, tenor 5g). Domanda: nella griglia onesta
    distanza z ∈ {1.0, 1.5, 2.0, 2.5}σ  ×  tenor ∈ {3, 5, 7, 10}g  ×  ali dz ∈ {+0.5, +1.0, +2.0}σ
    ×  lato {put-only, call-only, entrambi}  ×  struttura {vertical, condor, diagonal T+1}
esiste una cella che batte VRP01 canonico (put credit spread settimanale Δ-0.28/-0.10, gate
IV-rank) in modo che SOPRAVVIVE a (a) selezione IN-SAMPLE-ONLY, (b) deflated-Sharpe sul numero
TOTALE di celle, (c) banda f, (d) plateau dei vicini, (e) null del de-levering?

MAPPATURA lato×struttura (9 combo nominali -> 6 DISTINTE, per non contare doppio):
    vertical×put  = VERT-PUT      vertical×call = VERT-CALL     vertical×both ≡ CONDOR
    condor×put ≡ VERT-PUT         condor×call ≡ VERT-CALL       condor×both  = CONDOR
    diagonal×{put,call,both} = DIAG-PUT / DIAG-CALL / DIAG-2 (Albimarini)
Totale celle = 4z × 4tenor × 3dz × 6 strutture = 288 (tutte contate nel deflated-Sharpe).

REGOLE RISPETTATE:
  - Gate IV-rank CANONICO sempre attivo, NON riottimizzato (vrp>0 AND 0.30<=ivr<=0.90,
    identico a VRP01 combo e a r0702_alb_structure gated=True).
  - Selezione cella SOLO su Sharpe PRE-holdout (2021-03 .. 2024-12); hold-out 2025-26 mai
    guardato per scegliere. DSR (Bailey & LdP, altlib.deflated_sharpe) su tutte le 288 celle.
  - Pattern "0-perdite = Sharpe implausibile" (CC01, ALB-A): le celle con < MIN_LOSS_IS
    perdite attive in-sample sono ESCLUSE DALLA SELEZIONE E DICHIARATE (coda mai campionata
    -> Sharpe non informativo). Il criterio usa SOLO dati in-sample (niente peek).
  - Banda f {0.6, 0.8, 1.0, 1.3} + scenario skew (f_put=1.3 / f_call=0.7) su ogni claim
    (pricing BS FLAT su DVOL-30g: il deep-OTM e' banda, non stima puntuale).
  - Banda d'ancora (regola 2026-07-02): la cella scelta si riporta su TUTTE le fasi di
    partenza 0..tenor-1 (il costrutto e' ancorato alla cadenza tenor_d).
  - NULL DEL DE-LEVERING (lezione TP01×DVOL): ogni vantaggio di DD della cella si confronta
    con VRP01 semplicemente scalato allo stesso DD (Sharpe invariante per scala).
  - Confronto apples-to-apples: oltre a VRP01 canonico (motore options_vrp_v2, capitale=K_short,
    fee=12.5% del premio) si riporta il BRIDGE (stessa struttura di VRP01 nel motore nuovo:
    vert-put z=0.583 dz=0.699 7g, capitale=S0, fee per-gamba) — battere solo VRP01 canonico
    ma non il bridge = artefatto di convenzione fee/capitale, non struttura.

MACCHINERIA RIUSATA (non riscritta): motore di r0702_alb_structure (bs_put/bs_call/_fee_frac/
metrics/to_daily_lumped, VALIDATO vs run_structure cella-per-cella in testa al run),
options_vrp_v2.vrp_spread_weekly (VRP01 canonico esatto), altlib.deflated_sharpe/marginal_vs_tp01.

Regola standing: NIENTE short-vol da modello in deploy — l'esito massimo e' conoscenza/LEAD.

    uv run python scripts/research/r0703_vrpimp_structgrid.py
"""
from __future__ import annotations
import json
import math
import sys
from pathlib import Path

PROJECT_ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(PROJECT_ROOT))
sys.path.insert(0, str(PROJECT_ROOT / "scripts" / "research" / "alt"))
import numpy as np, pandas as pd  # noqa: E402
from scipy.stats import norm  # noqa: E402

from scripts.research.options_vrp_lab import bs_put, load_series, per_year  # noqa: E402
from scripts.research.options_vrp_v2 import vrp_spread_weekly, _ivrank, _rv30  # noqa: E402
from scripts.research.r0702_alb_structure import (  # noqa: E402
    bs_call, _fee_frac, run_structure, metrics, to_daily_lumped, DAY, HOLDOUT)
import altlib as al  # noqa: E402

SCRATCH = Path("/tmp/claude-1001/-opt-docker-PythagorasGoal/e00896d3-d4bb-4f2a-b471-55a1d88a12ba/scratchpad")

F_SWEEP = (0.6, 0.8, 1.0, 1.3)
F_SKEW = dict(f_put=1.3, f_call=0.7)          # skew crypto-shaped: put ricche, call povere
Z_GRID = (1.0, 1.5, 2.0, 2.5)
TENOR_GRID = (3, 5, 7, 10)
DZ_GRID = (0.5, 1.0, 2.0)
STRUCTS = (("same", "put", "VERT-PUT"), ("same", "call", "VERT-CALL"), ("same", "both", "CONDOR"),
           ("diag", "put", "DIAG-PUT"), ("diag", "call", "DIAG-CALL"), ("diag", "both", "DIAG-2"))
MIN_ACT_IS = 30      # trade attivi minimi in-sample per credere allo Sharpe IS
MIN_LOSS_IS = 3      # perdite attive minime IS: <3 = coda mai campionata (CC01/ALB-A) -> ESCLUSA
CUTS = ("2022-01-01", "2023-01-01", "2024-01-01", "2025-01-01")   # persistenza multi-cut

# bridge = la struttura ESATTA di VRP01 dentro il motore nuovo (delta -0.28/-0.10, 7g)
Z_BRIDGE = float(-norm.ppf(0.28))                     # ~0.583
DZ_BRIDGE = float(-norm.ppf(0.10)) - Z_BRIDGE         # ~0.699


# --------------------------------------------------------------------------- dati + gate cache
_S: dict = {}


def S(asset):
    """(px, dv, idx, skip) con gate canonico VRP01 precomputato (identico a r0702/options_vrp_v2)."""
    if asset not in _S:
        J = load_series(asset)
        px = J["px"].values.astype(float)
        dv = (J["dvol"].values / 100.0).astype(float)
        n = len(px)
        skip = np.zeros(n, dtype=bool)
        for i in range(n):
            rv = _rv30(px, i)
            ivr = _ivrank(dv, i)
            skip[i] = ((not np.isnan(rv) and (dv[i] - rv) <= 0)
                       or (not np.isnan(ivr) and (ivr < 0.30 or ivr > 0.90)))
        _S[asset] = (px, dv, J.index, skip)
    return _S[asset]


# --------------------------------------------------------------------------- motore generalizzato
def run_cell(asset, expiry, side, z, dz, tenor_d, f_put=1.0, f_call=1.0, offset=0):
    """Vendita sistematica non-overlapping della struttura, cadenza tenor_d, GATE CANONICO SEMPRE.

    expiry: 'same' (long stessa scadenza) | 'diag' (long T+1g, mark BS a exit — vega)
    side:   'put' | 'call' | 'both'
    Identica contabilita' di r0702_alb_structure.run_structure (validata sotto): capitale = S0,
    fee Deribit per gamba 0.03% notional cap 12.5% premio, delivery 0.015% su short ITM, exit fee
    sulle long residue del diag. offset = fase d'ancora (banda d'ancora)."""
    px, dv, idx, skip = S(asset)
    n = len(px)
    T = tenor_d / 365.25
    T_long = T + DAY if expiry == "diag" else T
    rets = {}
    i = 60 + offset
    while i + tenor_d < n:
        j = i + tenor_d
        if skip[i]:
            rets[idx[j]] = 0.0
            i = j
            continue
        S0 = px[i]; sig = dv[i]; m = sig * math.sqrt(T)
        S1 = px[j]; sig1 = dv[j]
        credit = short_pay = long_val = exit_fee = deliv = 0.0
        legs = []
        if side in ("put", "both"):
            Ks = S0 * math.exp(-z * m); Kl = S0 * math.exp(-(z + dz) * m)
            ps = bs_put(S0, Ks, T, sig) / S0 * f_put
            pl = bs_put(S0, Kl, T_long, sig) / S0 * f_put
            credit += ps - pl; legs += [ps, pl]
            short_pay += max(0.0, Ks - S1) / S0
            deliv += _fee_frac(max(0.0, Ks - S1) / S0, rate=0.00015)
            if expiry == "diag":
                lv = bs_put(S1, Kl, DAY, sig1) / S0 * f_put
                long_val += lv
                exit_fee += _fee_frac(lv, notional_ratio=S1 / S0)
            else:
                long_val += max(0.0, Kl - S1) / S0
        if side in ("call", "both"):
            Ks = S0 * math.exp(+z * m); Kl = S0 * math.exp(+(z + dz) * m)
            cs = bs_call(S0, Ks, T, sig) / S0 * f_call
            cl = bs_call(S0, Kl, T_long, sig) / S0 * f_call
            credit += cs - cl; legs += [cs, cl]
            short_pay += max(0.0, S1 - Ks) / S0
            deliv += _fee_frac(max(0.0, S1 - Ks) / S0, rate=0.00015)
            if expiry == "diag":
                lv = bs_call(S1, Kl, DAY, sig1) / S0 * f_call
                long_val += lv
                exit_fee += _fee_frac(lv, notional_ratio=S1 / S0)
            else:
                long_val += max(0.0, S1 - Kl) / S0
        entry_fee = sum(_fee_frac(v) for v in legs)
        rets[idx[j]] = credit - short_pay + long_val - entry_fee - exit_fee - deliv
        i = j
    return pd.Series(rets)


def book_cell(expiry, side, z, dz, tenor_d, **kw):
    rB = run_cell("BTC", expiry, side, z, dz, tenor_d, **kw)
    rE = run_cell("ETH", expiry, side, z, dz, tenor_d, **kw)
    return pd.concat({"B": rB, "E": rE}, axis=1, join="inner").mean(axis=1)


def vrp01_book(f):
    return pd.concat({a[0]: vrp_spread_weekly(a, defined_risk=True, f=f, gate_vrp=True,
                                              gate_ivr=0.30, crash_skip=0.90)
                      for a in ("BTC", "ETH")}, axis=1, join="inner").mean(axis=1)


# --------------------------------------------------------------------------- utilita' report
def _sh_window(r, tenor_d, start=None, end=None):
    w = r
    if start is not None:
        w = w[w.index >= pd.Timestamp(start, tz="UTC")]
    if end is not None:
        w = w[w.index < pd.Timestamp(end, tz="UTC")]
    ppy = 365.25 / tenor_d
    return float(w.mean() / w.std() * np.sqrt(ppy)) if len(w) > 5 and w.std() > 0 else float("nan")


def dd_of(r, lam=1.0):
    eq = np.cumprod(1 + lam * r.values)
    pk = np.maximum.accumulate(eq)
    return float(np.max((pk - eq) / pk))


def scale_to_dd(r, dd_target):
    """λ tale che il maxDD di λ·r == dd_target (null del de-levering)."""
    lo, hi = 0.01, 3.0
    for _ in range(60):
        mid = 0.5 * (lo + hi)
        if dd_of(r, mid) > dd_target:
            hi = mid
        else:
            lo = mid
    return 0.5 * (lo + hi)


def validate_engine():
    """run_cell deve riprodurre ESATTAMENTE run_structure (motore ALB-A validato) su 3 kind."""
    print("  [validazione motore] run_cell vs r0702_alb_structure.run_structure (z=2, dz=1, 5g, gated):")
    ok = True
    for kind, (expiry, side) in (("diag", ("diag", "both")), ("condor", ("same", "both")),
                                 ("vert", ("same", "put"))):
        for a in ("BTC", "ETH"):
            ref = run_structure(a, kind, z=2.0, dz=1.0, tenor_d=5, gated=True)
            new = run_cell(a, expiry, side, 2.0, 1.0, 5)
            d = float((ref - new).abs().max()) if len(ref) == len(new) else float("inf")
            ok &= d < 1e-12
            print(f"    {kind:<7}{a}: n={len(new):>4}  max|Δ|={d:.2e}")
    if not ok:
        raise SystemExit("ENGINE MISMATCH: run_cell non riproduce run_structure — stop.")
    print("    -> motore identico (riuso validato, non riscrittura).")


def main():
    print("=" * 112)
    print("  R0703 VRPIMP-STRUCTGRID — griglia onesta 288 celle di struttura short-vol vs VRP01 canonico")
    print("  Gate IV-rank canonico SEMPRE attivo (mai riottimizzato). Selezione IN-SAMPLE-ONLY (pre-2025).")
    print("  ⚠️ SKEW: pricing BS FLAT su DVOL-30g -> banda f {0.6,0.8,1.0,1.3} + scenario fp=1.3/fc=0.7.")
    print("  Regola standing: NIENTE short-vol da modello in deploy — esito massimo = conoscenza/LEAD.")
    print("=" * 112)

    validate_engine()

    # ------------------------------------------------------------- (1) VRP01 canonico + bridge
    print("\n  (1) BASELINE — VRP01 canonico (options_vrp_v2 COMBO) e bridge motore-nuovo, banda f")
    hdr = (f"  {'riga':<38} {'ShF':>6} {'ShIS':>6} {'ShH':>6} {'CAGR':>7} {'maxDD':>6} "
           f"{'worst':>7} {'win%':>5} {'att%':>5}")
    print(hdr)
    vrp = {}
    for f in F_SWEEP:
        vrp[f] = vrp01_book(f)
        mm = metrics(vrp[f], 7); mi = metrics(vrp[f][vrp[f].index < HOLDOUT], 7)
        print(f"  VRP01 canonico f={f:<4} {'':<16} {mm['sh']:>6.2f} {mi['sh']:>6.2f} {mm['sh_h']:>6.2f} "
              f"{mm['cagr']*100:>+6.1f}% {mm['dd']*100:>5.1f}% {mm['worst']*100:>+6.2f}% "
              f"{mm['win']*100:>4.0f}% {mm['act']*100:>4.0f}%")
    bridge = {}
    for f in F_SWEEP:
        bridge[f] = book_cell("same", "put", Z_BRIDGE, DZ_BRIDGE, 7, f_put=f, f_call=f)
        mm = metrics(bridge[f], 7); mi = metrics(bridge[f][bridge[f].index < HOLDOUT], 7)
        print(f"  bridge vert-put Δ-0.28/-0.10 7g f={f:<4} {mm['sh']:>6.2f} {mi['sh']:>6.2f} {mm['sh_h']:>6.2f} "
              f"{mm['cagr']*100:>+6.1f}% {mm['dd']*100:>5.1f}% {mm['worst']*100:>+6.2f}% "
              f"{mm['win']*100:>4.0f}% {mm['act']*100:>4.0f}%")
    print("     (bridge = stessa struttura di VRP01 nel motore-griglia: e' il confronto apples-to-apples;")
    print("      battere VRP01 ma non il bridge = artefatto di convenzione fee/capitale, non struttura)")

    # ------------------------------------------------------------- (2) griglia 288 celle, f=1.0
    print(f"\n  (2) GRIGLIA {len(STRUCTS)}x{len(Z_GRID)}x{len(DZ_GRID)}x{len(TENOR_GRID)} = "
          f"{len(STRUCTS)*len(Z_GRID)*len(DZ_GRID)*len(TENOR_GRID)} celle (f=1.0, gate canonico)")
    cells = {}
    for expiry, side, lab in STRUCTS:
        for z in Z_GRID:
            for dz in DZ_GRID:
                for tn in TENOR_GRID:
                    r = book_cell(expiry, side, z, dz, tn)
                    r_is = r[r.index < HOLDOUT]
                    act_is = r_is[r_is != 0]
                    rec = dict(expiry=expiry, side=side, lab=lab, z=z, dz=dz, tn=tn, r=r,
                               mi=metrics(r_is, tn), mm=metrics(r, tn),
                               nact_is=int(len(act_is)), nloss_is=int((act_is < 0).sum()))
                    rec["eligible"] = (rec["nact_is"] >= MIN_ACT_IS and rec["nloss_is"] >= MIN_LOSS_IS)
                    cells[(lab, z, dz, tn)] = rec
    all_full_sh = [c["mm"]["sh"] for c in cells.values()]
    all_is_sh = [c["mi"]["sh"] for c in cells.values()]
    n_cells = len(cells)
    inel = [c for c in cells.values() if not c["eligible"]]
    print(f"     celle totali {n_cells} | ESCLUSE dalla selezione (implausibili: <{MIN_LOSS_IS} perdite IS "
          f"o <{MIN_ACT_IS} trade IS): {len(inel)} — dichiarate sotto, contate comunque nel DSR")

    # il pattern '0-perdite': cosa avremmo scelto SENZA il filtro
    naive = max(cells.values(), key=lambda c: c["mi"]["sh"])
    print(f"\n     [pattern CC01/ALB-A] best IS SENZA filtro implausibilita': {naive['lab']} z={naive['z']} "
          f"dz={naive['dz']} {naive['tn']}g -> ShIS {naive['mi']['sh']:.2f} (perdite IS: {naive['nloss_is']}, "
          f"trade IS: {naive['nact_is']}) | suo hold-out ShH {naive['mm']['sh_h']:+.2f}")
    top_inel = sorted(inel, key=lambda c: c["mi"]["sh"], reverse=True)[:8]
    print("     top celle ESCLUSE (ShIS alto MA coda mai campionata in-sample -> Sharpe non informativo):")
    for c in top_inel:
        print(f"       {c['lab']:<10} z={c['z']} dz={c['dz']} {c['tn']:>2}g  ShIS {c['mi']['sh']:>6.2f}  "
              f"perdite-IS {c['nloss_is']:>2} su {c['nact_is']:>3} trade  ->  ShH {c['mm']['sh_h']:>+6.2f}")

    # ------------------------------------------------------------- (3) selezione in-sample-only
    elig = [c for c in cells.values() if c["eligible"]]
    ch = max(elig, key=lambda c: c["mi"]["sh"])
    print(f"\n  (3) SELEZIONE IN-SAMPLE-ONLY (fra le {len(elig)} eleggibili) + top-10")
    print(f"  {'cella':<34} {'ShIS':>6} {'ShF':>6} {'ShH':>6} {'DD':>6} {'worst':>7} {'lossIS':>7}")
    for c in sorted(elig, key=lambda c: c["mi"]["sh"], reverse=True)[:10]:
        mark = "  <== SCELTA" if c is ch else ""
        print(f"  {c['lab']:<10} z={c['z']} dz={c['dz']} tenor={c['tn']:>2}g{'':<6} {c['mi']['sh']:>6.2f} "
              f"{c['mm']['sh']:>6.2f} {c['mm']['sh_h']:>6.2f} {c['mm']['dd']*100:>5.1f}% "
              f"{c['mm']['worst']*100:>+6.2f}% {c['nloss_is']:>4}/{c['nact_is']:<4}{mark}")

    tn = ch["tn"]
    dsr_full, sr0_full = al.deflated_sharpe(ch["mm"]["sh"], all_full_sh, ch["r"], dpy=365.25 / tn)
    r_is = ch["r"][ch["r"].index < HOLDOUT]
    dsr_is, sr0_is = al.deflated_sharpe(ch["mi"]["sh"], all_is_sh, r_is, dpy=365.25 / tn)
    print(f"\n     DSR cella scelta (N={n_cells} trial): FULL {dsr_full:.3f} (null-max ~{sr0_full:.2f}) | "
          f"IS {dsr_is:.3f} (null-max ~{sr0_is:.2f}) | PASS richiede >= 0.95")

    # nota anti-hindsight: la cella col miglior HOLD-OUT fra le eleggibili NON e' selezionabile
    # (selection-on-holdout, gate 2026-06-29); la riporto solo per chiudere la domanda ovvia.
    hb = max(elig, key=lambda c: c["mm"]["sh_h"])
    dsr_hb, _ = al.deflated_sharpe(hb["mm"]["sh"], all_full_sh, hb["r"], dpy=365.25 / hb["tn"])
    rank_is = 1 + sum(1 for c in elig if c["mi"]["sh"] > hb["mi"]["sh"])
    print(f"     [anti-hindsight] best HOLD-OUT fra le eleggibili: {hb['lab']} z={hb['z']} dz={hb['dz']} "
          f"{hb['tn']}g (ShIS {hb['mi']['sh']:.2f}, rank-IS #{rank_is}, ShH {hb['mm']['sh_h']:.2f}, "
          f"DSR {dsr_hb:.3f}) — sceglierla = selection-on-holdout, VIETATO; e comunque DSR<0.95.")

    # ------------------------------------------------------------- (4) cella scelta: banda f vs VRP01
    print(f"\n  (4) CELLA SCELTA {ch['lab']} z={ch['z']} dz={ch['dz']} {tn}g — banda f vs VRP01 e bridge")
    print(f"  {'f':<22} {'cella ShF/ShH':>16} {'VRP01 ShF/ShH':>16} {'bridge ShF/ShH':>16} "
          f"{'cella DD/worst':>17} {'VRP01 DD/worst':>17}")
    ch_f = {}
    beats_vrp = beats_bridge = True
    for f in F_SWEEP:
        rr = book_cell(ch["expiry"], ch["side"], ch["z"], ch["dz"], tn, f_put=f, f_call=f)
        ch_f[f] = rr
        m = metrics(rr, tn); v = metrics(vrp[f], 7); b = metrics(bridge[f], 7)
        beats_vrp &= (m["sh"] > v["sh"]) and (m["sh_h"] > v["sh_h"])
        beats_bridge &= (m["sh"] > b["sh"]) and (m["sh_h"] > b["sh_h"])
        print(f"  f={f:<20} {m['sh']:>7.2f}/{m['sh_h']:>6.2f} {v['sh']:>8.2f}/{v['sh_h']:>6.2f} "
              f"{b['sh']:>8.2f}/{b['sh_h']:>6.2f} {m['dd']*100:>7.1f}%/{m['worst']*100:>+6.2f}% "
              f"{v['dd']*100:>7.1f}%/{v['worst']*100:>+6.2f}%")
    rr = book_cell(ch["expiry"], ch["side"], ch["z"], ch["dz"], tn, **F_SKEW)
    m = metrics(rr, tn)
    print(f"  SKEW fp=1.3/fc=0.7    {m['sh']:>7.2f}/{m['sh_h']:>6.2f}    (VRP01/bridge non hanno lato call)")
    py_c = per_year(ch_f[1.0]); py_v = per_year(vrp[1.0])
    print("     per-anno cella  f=1.0: " + "  ".join(f"{y}:{v*100:+5.1f}%" for y, v in sorted(py_c.items())))
    print("     per-anno VRP01  f=1.0: " + "  ".join(f"{y}:{v*100:+5.1f}%" for y, v in sorted(py_v.items())))

    # persistenza multi-cut del presunto vantaggio (ΔSh cella - bridge, finestre [cut, end))
    print("     multi-cut ΔSh (cella - bridge | cella - VRP01) su [cut, fine):")
    for cut in CUTS:
        d_b = _sh_window(ch_f[1.0], tn, start=cut) - _sh_window(bridge[1.0], 7, start=cut)
        d_v = _sh_window(ch_f[1.0], tn, start=cut) - _sh_window(vrp[1.0], 7, start=cut)
        print(f"       {cut}:  {d_b:+.2f} | {d_v:+.2f}")

    # ------------------------------------------------------------- (5) banda d'ancora
    print(f"\n  (5) BANDA D'ANCORA — cella scelta su tutte le {tn} fasi di partenza (offset 0..{tn-1})")
    anch = []
    for o in range(tn):
        ro = book_cell(ch["expiry"], ch["side"], ch["z"], ch["dz"], tn, offset=o)
        mo = metrics(ro, tn)
        anch.append((o, mo["sh"], mo["sh_h"]))
        print(f"       offset {o}: ShF {mo['sh']:>5.2f}  ShH {mo['sh_h']:>+5.2f}")
    shf = [a[1] for a in anch]; shh = [a[2] for a in anch]
    print(f"     banda ShF [{min(shf):.2f}, {max(shf):.2f}] mediana {np.median(shf):.2f} | "
          f"ShH [{min(shh):+.2f}, {max(shh):+.2f}] mediana {np.median(shh):+.2f}")

    # ------------------------------------------------------------- (6) plateau dei vicini
    print(f"\n  (6) PLATEAU — slice {ch['lab']} dz={ch['dz']}: matrice z × tenor (ShIS / ShH)")
    print("       " + "".join(f"{t:>14}g" for t in TENOR_GRID))
    for z in Z_GRID:
        rowtxt = f"  z={z:<4}"
        for t in TENOR_GRID:
            c = cells[(ch["lab"], z, ch["dz"], t)]
            star = "*" if (z == ch["z"] and t == tn) else " "
            rowtxt += f"  {c['mi']['sh']:>5.2f}/{c['mm']['sh_h']:>+5.2f}{star}"
        print(rowtxt)
    print("     vicini dz (a z/tenor scelti): " + "  ".join(
        f"dz={d}: ShIS {cells[(ch['lab'], ch['z'], d, tn)]['mi']['sh']:.2f}/"
        f"ShH {cells[(ch['lab'], ch['z'], d, tn)]['mm']['sh_h']:+.2f}" for d in DZ_GRID))
    neigh = []
    zi, ti, di = Z_GRID.index(ch["z"]), TENOR_GRID.index(tn), DZ_GRID.index(ch["dz"])
    for (gi, grid, mk) in ((zi, Z_GRID, "z"), (ti, TENOR_GRID, "tn"), (di, DZ_GRID, "dz")):
        for step in (-1, +1):
            k = gi + step
            if 0 <= k < len(grid):
                key = dict(z=ch["z"], tn=tn, dz=ch["dz"]); key[mk] = grid[k]
                neigh.append(cells[(ch["lab"], key["z"], key["dz"], key["tn"])])
    n_pos = sum(1 for c in neigh if c["mi"]["sh"] > 0 and c["mm"]["sh_h"] > 0)
    print(f"     vicini adiacenti (±1 passo per asse): {len(neigh)} | con ShIS>0 E ShH>0: {n_pos}")

    # ------------------------------------------------------------- (7) null del de-levering
    print("\n  (7) NULL DEL DE-LEVERING — il vantaggio DD della cella e' replicabile scalando VRP01?")
    m_c = metrics(ch_f[1.0], tn); m_v = metrics(vrp[1.0], 7)
    lam = scale_to_dd(vrp[1.0], m_c["dd"])
    scaled = lam * vrp[1.0]
    m_s = metrics(scaled, 7)
    print(f"     cella:              Sh {m_c['sh']:.2f} / ShH {m_c['sh_h']:.2f}  DD {m_c['dd']*100:.1f}%  "
          f"worst {m_c['worst']*100:+.2f}%  CAGR {m_c['cagr']*100:+.1f}%")
    print(f"     VRP01 pieno:        Sh {m_v['sh']:.2f} / ShH {m_v['sh_h']:.2f}  DD {m_v['dd']*100:.1f}%  "
          f"worst {m_v['worst']*100:+.2f}%  CAGR {m_v['cagr']*100:+.1f}%")
    print(f"     VRP01 × λ={lam:.2f}:     Sh {m_s['sh']:.2f} / ShH {m_s['sh_h']:.2f}  DD {m_s['dd']*100:.1f}%  "
          f"worst {m_s['worst']*100:+.2f}%  CAGR {m_s['cagr']*100:+.1f}%")
    delever_kills = (m_c["dd"] < m_v["dd"]) and (m_s["sh"] >= m_c["sh"]) and (m_s["sh_h"] >= m_c["sh_h"])
    print("     -> lo scaling lascia lo Sharpe invariato: ogni vantaggio di DD e' replicabile con λ,"
          f" la cella vale SOLO se Sh/ShH superiori. delever_null_kills={delever_kills}")

    # ------------------------------------------------------------- (8) marginale/corr
    print("\n  (8) CORRELAZIONE + MARGINALE (informativo, non promozione: regola standing short-vol)")
    d_c = to_daily_lumped(ch_f[1.0]); d_v = to_daily_lumped(vrp[1.0])
    w_c = (1 + d_c).resample("168h", origin="epoch").prod() - 1   # origin comune (lezione '7D')
    w_v = (1 + d_v).resample("168h", origin="epoch").prod() - 1
    Jw = pd.concat({"c": w_c, "v": w_v}, axis=1, join="inner").dropna()
    print(f"     corr settimanale cella~VRP01: {Jw['c'].corr(Jw['v']):+.2f} "
          f"(alta = stesso trade in altri vestiti)")
    mv = al.marginal_vs_tp01(d_c)
    print(f"     marginal_vs_tp01[cella]: verdict={mv.get('marginal_verdict')} corr={mv.get('corr_full')} "
          f"IS-Sh={mv.get('cand_insample_sharpe')} insample_edge={mv.get('has_insample_edge')} "
          f"hedge={mv.get('is_hedge')} robust_oos={mv.get('robust_oos')}")

    # ------------------------------------------------------------- (9) verdetto
    print("\n  (9) VERDETTO")
    dsr_pass = bool(np.isfinite(dsr_full) and dsr_full >= 0.95 and np.isfinite(dsr_is) and dsr_is >= 0.95)
    wins = beats_vrp and beats_bridge and dsr_pass and not delever_kills
    print(f"     batte VRP01 su tutta la banda f (ShF e ShH): {beats_vrp}")
    print(f"     batte il bridge (stesso motore) su tutta la banda f: {beats_bridge}")
    print(f"     DSR>=0.95 su {n_cells} celle (FULL {dsr_full:.3f} / IS {dsr_is:.3f}): {dsr_pass}")
    print(f"     sopravvive al null del de-levering: {not delever_kills}")
    print(f"     ==> {'ESISTE una cella che batte VRP01 onestamente' if wins else 'NESSUNA cella batte VRP01 onestamente'}")
    print("     (esecuzione: comunque STAT-MODE — niente short-vol da modello in deploy;")
    print("      muri di size Deribit invariati dal filone capital-scaling: spread ETH ~2.6k+, BTC ~4.7k+)")

    # dump metriche per il report
    SCRATCH.mkdir(parents=True, exist_ok=True)
    dump = {f"{k[0]}|z{k[1]}|dz{k[2]}|t{k[3]}": dict(
        is_sh=c["mi"]["sh"], full_sh=c["mm"]["sh"], hold_sh=c["mm"]["sh_h"], dd=c["mm"]["dd"],
        worst=c["mm"]["worst"], nact_is=c["nact_is"], nloss_is=c["nloss_is"], eligible=c["eligible"])
        for k, c in cells.items()}
    (SCRATCH / "r0703_structgrid_results.json").write_text(json.dumps(dump, indent=1))
    print(f"\n  [dump] {SCRATCH / 'r0703_structgrid_results.json'}")


if __name__ == "__main__":
    main()