research(tail-hedge): protezione DD combo (incl. opzioni) -> vince la guardia-drawdown

Goal: sleeve/overlay protettivo per il combo (TP01+GTAA), anni tipo 2022, valutare opzioni.
Diagnosi: DD combo 8.4% e' grind-lento (2022 -4.4%), non crash -> il doppio trend gia' taglia i crash.

Test (tail_hedge_lab.py): guardia-DD -4% -> MaxDD 8.4->5.8%, 2022 -4.4->-1.8%, Sharpe 1.48->1.38,
CAGR 9.2%. Vol-target NON aiuta (2022 non e' vol-spike). OPZIONI (put/put-spread LONG su BTC/ETH,
premio BS su DVOL): sempre-on ~50%/anno -> con budget 3%/y effetto ~nullo, e nel grind 2022 sanguinano;
pagano solo nei crash secchi (stress -30%: put +25% netto). -> black-swan insurance cara, fuori
bersaglio per il 2022. A leva: guard rende il 2x sopportabile (2022 -10.9%), il 3x resta margin-call.

RACCOMANDAZIONE: aggiungere guardia-drawdown di portafoglio (no premio); opzioni solo eventuale
micro-hedge black-swan. Costo onesto del guard: -2.1pp CAGR per dimezzare il MaxDD.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

scripts/research/tail_hedge_lab.py

@@ -0,0 +1,131 @@
+"""TAIL-HEDGE LAB — proteggere il DD del combo (TP01+GTAA) e gli anni tipo 2022. Valuta OPZIONI.
+
+Il DD del combo (8.4%) e' grind-lento (2022), non crash. Le PUT proteggono i CRASH (rischio latente
+gap/overnight + leva), non il grind. Quindi confronto:
+  (A) OPZIONI: put-spread LONG su indice 50/50 BTC/ETH (mirror di VRP01), always-on vs GATED (hold
+      l'hedge solo quando esposti al trend / quando IV economica). Premio BS su DVOL reale, payoff sul
+      path. Misura il BLEED nei calmi + il payoff nei crash (+ stress sintetico -30% overnight).
+  (B) GUARDIA DRAWDOWN: de-risk il combo quando il DD da picco supera X% (o vol spike).
+  (C) VOL-TARGET: cappa la vol del combo a un livello piu' basso.
+Metriche: Sharpe, MaxDD, anno 2022, drag medio nei calmi, e payoff a uno shock -30%.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from combo_yearly_report import combo_daily
+from src.data.downloader import load_data
+from src.strategies.trend_portfolio import resample_1d
+from src.portfolio.sleeves import _bs_put, _strike_from_delta, _HL_DIR, _tp01_returns
+from scipy.stats import norm
+
+ANN = np.sqrt(252.0)
+
+
+def _sh(r): r = np.asarray(pd.Series(r).dropna(), float); return float(np.mean(r)/np.std(r)*ANN) if len(r)>5 and np.std(r)>0 else 0.0
+def _dd(r): eq=np.cumprod(1+np.asarray(r,float)); pk=np.maximum.accumulate(eq); return float(np.max((pk-eq)/pk)) if len(eq) else 0.0
+def _yr(r,y): return float(np.prod(1+r[r.index.year==y].values)-1) if (r.index.year==y).any() else 0.0
+
+
+def crypto_index():
+    """Indice 50/50 BTC/ETH (prezzo daily) + DVOL medio, per il pricing dell'hedge."""
+    px={}; dv={}
+    for a in ("BTC","ETH"):
+        df=resample_1d(load_data(a,"1h")); s=pd.Series(df["close"].values.astype(float),index=pd.to_datetime(df["datetime"]))
+        if s.index.tz is None: s.index=s.index.tz_localize("UTC")
+        px[a]=s
+        d=pd.read_parquet(_HL_DIR/f"dvol_{a.lower()}.parquet")
+        dv[a]=pd.Series(d["close"].values.astype(float),index=pd.to_datetime(d["timestamp"],unit="ms",utc=True))
+    P=pd.concat(px,axis=1,join="inner").dropna(); D=pd.concat(dv,axis=1,join="inner").dropna()
+    idx_ret=0.5*P["BTC"].pct_change()+0.5*P["ETH"].pct_change()
+    dvol=(0.5*D["BTC"]+0.5*D["ETH"]).reindex(P.index).ffill()/100.0
+    return idx_ret.dropna(), dvol
+
+
+def hedge_overlay(idx_ret, dvol, kind="spread", buy_delta=-0.30, sell_delta=-0.10, tenor_d=7, gate_ivr=None):
+    """P&L settimanale per unita' di nozionale hedge di una protezione LONG comprata ogni settimana
+    sull'indice. kind='spread' = put-spread debit (compra strike vicino buy_delta, vende deep-OTM
+    sell_delta); kind='put' = long put nuda (buy_delta). gate_ivr: compra solo se IV-rank < soglia.
+    Ritorna (pnl_daily, premio_annuo_per_unita)."""
+    idx=idx_ret.index; r=idx_ret.values; sig=dvol.reindex(idx).ffill().values
+    S=np.cumprod(1+r); n=len(S)
+    ivr=pd.Series(sig,index=idx).rolling(252,min_periods=60).apply(lambda x:(x[-1]>=x).mean(),raw=True).values
+    out=np.zeros(n); prem_tot=0.0; i=30; T=tenor_d/365.25
+    while i+tenor_d<n:
+        if gate_ivr is not None and (not np.isfinite(ivr[i]) or ivr[i]>gate_ivr):
+            i+=tenor_d; continue
+        S0=S[i]; vol=sig[i]; ST=S[i+tenor_d]
+        Kb=_strike_from_delta(S0,T,vol,buy_delta)
+        if kind=="put":
+            prem=_bs_put(S0,Kb,T,vol); payoff=max(Kb-ST,0)
+        else:
+            Ks=_strike_from_delta(S0,T,vol,sell_delta)               # Kb>Ks (compra vicino, vende lontano)
+            prem=_bs_put(S0,Kb,T,vol)-_bs_put(S0,Ks,T,vol); payoff=max(Kb-ST,0)-max(Ks-ST,0)
+        fee=0.0005*S0
+        out[i+tenor_d]=(payoff-prem-fee)/S0; prem_tot+=(prem+fee)/S0
+        i+=tenor_d
+    yrs=(idx[-1]-idx[0]).days/365.25
+    return pd.Series(out,index=idx), (prem_tot/yrs if yrs>0 else 0.0)
+
+
+def dd_guard(combo, dd_trigger=0.05, look=20):
+    """De-risk: se il DD da picco supera dd_trigger -> esposizione 0.5 finche' non recupera meta'."""
+    r=combo.values; n=len(r); eq=np.cumprod(1+r); pk=np.maximum.accumulate(eq)
+    expo=np.ones(n); on=True
+    for i in range(1,n):
+        ddi=(pk[i-1]-eq[i-1])/pk[i-1]
+        if ddi>dd_trigger: on=False
+        if ddi<dd_trigger*0.4: on=True
+        expo[i]=1.0 if on else 0.4
+    return pd.Series(expo*r,index=combo.index)
+
+
+def voltarget(combo, tv=0.07):
+    rv=combo.rolling(30,min_periods=15).std().shift(1)*ANN
+    sc=np.clip(np.nan_to_num(tv/rv.replace(0,np.nan).values,nan=0.0),0,1.5)
+    return pd.Series(combo.values*sc,index=combo.index)
+
+
+def line(name, r, base=None):
+    r=r.dropna()
+    extra=""
+    if base is not None:
+        b=base.reindex(r.index).dropna(); r2=r.reindex(b.index)
+        extra=f"  Δ2022 {(_yr(r2,2022)-_yr(b,2022))*100:+.1f}pp"
+    print(f"  {name:34} Sh {_sh(r):>5.2f}  MaxDD {_dd(r.values)*100:>4.1f}%  2022 {_yr(r,2022)*100:>+5.1f}%  "
+          f"CAGR {((np.prod(1+r.values))**(252/len(r))-1)*100:>+5.1f}%{extra}")
+
+
+def main():
+    print("="*100); print("  TAIL-HEDGE LAB — proteggere DD/2022 del combo (TP01+GTAA)"); print("="*100)
+    combo=combo_daily()
+    idx_ret,dvol=crypto_index()
+    print("\n  BASELINE")
+    line("combo (1x)", combo)
+
+    print("\n  (A) OPZIONI — protezione LONG su crypto, sovrapposta al combo (size = spendi ~3%/anno)")
+    for kind,gate,lbl in [("spread",None,"put-spread sempre"),("spread",0.4,"put-spread gate IVR<0.4"),
+                          ("put",None,"long put -0.30 sempre"),("put",0.4,"long put gate IVR<0.4")]:
+        ov,annprem=hedge_overlay(idx_ret,dvol,kind=kind,gate_ivr=gate)
+        ov=ov.reindex(combo.index).fillna(0.0)
+        size=0.03/annprem if annprem>0 else 0.0                   # nozionale hedge per ~3%/anno di premio
+        line(f"+{lbl} (~3%/y, size {size:.2f}x)", combo+size*ov, base=combo)
+    print("  (stress -30% overnight dell'indice crypto, per unita' di nozionale hedge):")
+    S0=1.0; vol=float(dvol.iloc[-1]); T=7/365.25
+    for kind in ("spread","put"):
+        Kb=_strike_from_delta(S0,T,vol,-0.30)
+        if kind=="put": prem=_bs_put(S0,Kb,T,vol); pay=max(Kb-0.7,0)
+        else: Ks=_strike_from_delta(S0,T,vol,-0.10); prem=_bs_put(S0,Kb,T,vol)-_bs_put(S0,Ks,T,vol); pay=max(Kb-0.7,0)-max(Ks-0.7,0)
+        print(f"     {kind:7}: premio {prem*100:.2f}% -> payoff a -30% {pay*100:.2f}% (netto {(pay-prem)*100:+.2f}%)")
+
+    print("\n  (B) GUARDIA DRAWDOWN (de-risk a -X% dal picco)")
+    for t in (0.04,0.06):
+        line(f"+dd-guard {t*100:.0f}%", dd_guard(combo,t), base=combo)
+    print("\n  (C) VOL-TARGET del combo")
+    for tv in (0.05,0.07):
+        line(f"+vol-target {tv*100:.0f}%", voltarget(combo,tv), base=combo)
+
+
+if __name__ == "__main__":
+    main()