From 67850b0dd8a25ea862d83cd5acf76fee362c405b Mon Sep 17 00:00:00 2001 From: Adriano Dal Pastro Date: Mon, 22 Jun 2026 21:48:35 +0000 Subject: [PATCH] research(equities): valida combo DEPLOYABLE TP01+GTAA (le due gambe eseguibili) Combo onesto/eseguibile a basso capitale: TP01 (Deribit, gia' armato) + GTAA vt12 (IB), senza XS01/VRP01 STAT-MODE. Finestra 2019-2026, TP01 compoundato sui giorni di borsa. RISULTATO: corr TP01<->GTAA +0.21; blend 50/50 Sharpe 1.48 (40/60 e risk-parity 1.52) > best solo 1.25, maxDD 14%->8%. DIVERSIFICA anche da deployable. CAVEAT: 2022 negativo (-2.64, trend whipsaw su entrambe), anni boom gonfiano l'assoluto (recenti ~0.95) -> il dato robusto e' il +0.27 di diversificazione, non il livello. Costo deployability: crypto-pieno+GTAA 1.81 vs 1.48 (i ~0.33 persi = XS01/VRP01 non eseguibili). Cross-venue Deribit+IB. Migliore config rischio-aggiustata EFFETTIVAMENTE eseguibile trovata post-reset. Non risolve EUR50/g (capitale). Prossimo: paper-trade GTAA su IB (forward-only) per validare l'esecuzione cross-venue. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../2026-06-22-deployable-combo-tp01-gtaa.md | 40 ++++++++ scripts/research/eq_tp01_gtaa_combo.py | 93 +++++++++++++++++++ 2 files changed, 133 insertions(+) create mode 100644 docs/diary/2026-06-22-deployable-combo-tp01-gtaa.md create mode 100644 scripts/research/eq_tp01_gtaa_combo.py diff --git a/docs/diary/2026-06-22-deployable-combo-tp01-gtaa.md b/docs/diary/2026-06-22-deployable-combo-tp01-gtaa.md new file mode 100644 index 0000000..1739e28 --- /dev/null +++ b/docs/diary/2026-06-22-deployable-combo-tp01-gtaa.md @@ -0,0 +1,40 @@ +# 2026-06-22 — Combo DEPLOYABLE: TP01 (Deribit) + GTAA (IB) + +## Perche' +Il combo crypto-pieno (TP01+XS01+VRP01)+GTAA diversificava (Sharpe 1.81), ma XS01/VRP01 sono +STAT-MODE (non eseguibili a $600). Validazione del combo ONESTO/eseguibile: solo le gambe deployable +a basso capitale — TP01 (gia' armato live su Deribit) + GTAA vt12 (eseguibile su IB, frazioni, +switch mensile). `eq_tp01_gtaa_combo.py`. TP01 compoundato sul calendario giorni-di-borsa. + +## Risultati (finestra comune 2019-03 .. 2026-06, ~7y) +| | Sharpe | CAGR | volAnn | maxDD | +|---|---|---|---|---| +| TP01 (crypto, Deribit) | 1.25 | 16.4% | 12.9% | 14% | +| GTAA vt12 (equity, IB) | 1.12 | 6.0% | 5.3% | 8% | +| **blend 50/50** | **1.48** | 11.3% | 7.5% | **8%** | +| blend 40/60 (best cap-mix) | 1.52 | 10.2% | 6.6% | 8% | +| risk-parity (29c/71e) | 1.52 | 9.1% | 5.9% | 8% | + +**corr TP01<->GTAA = +0.21**. Il blend (1.48-1.52) batte entrambe le gambe (best solo 1.25), +maxDD 14%->8%. **DIVERSIFICA anche da deployable.** + +## Caveat onesti +- Per-anno 50/50: 2019 2.11, 2020 2.51, 2021 1.66, **2022 -2.64**, 2023 1.40, 2024 1.73, 2025 0.98, + 2026 0.94. Anni boom iniziali gonfiano lo Sharpe assoluto; il **2022 e' negativo** (trend whipsaw + su entrambe le gambe nel bear). Recenti ~0.95. -> il numero robusto e' il GUADAGNO da + diversificazione (+0.27 Sharpe del blend vs solo), non il livello assoluto. +- **Costo deployability**: crypto-pieno+GTAA = 1.81 vs deployable = 1.48. I ~0.33 di Sharpe persi sono + cio' che XS01/VRP01 darebbero se eseguibili (servirebbe ~20k). +- **Cross-venue** Deribit+IB: due conti, capitale split. Entrambe switch mensile/basso turnover, + frazionabili a $0.5-2k. + +## Verdetto +Combo deployable VALIDO: due trend difensivi scorrelati (corr 0.21) su mercati diversi -> Sharpe +~1.5 / maxDD ~8%, meglio di ciascuna gamba. E' il candidato concreto per un paper-trade cross-venue. +NON risolve EUR50/g (resta capitale), ma e' la migliore configurazione rischio-aggiustata +EFFETTIVAMENTE eseguibile trovata finora. Lezione cross-mercato confermata: il salto di qualita' non +e' un nuovo alpha ma un SECONDO mercato scorrelato. + +## Prossimo (se si procede) +Paper-trade della gamba GTAA su IB (forward-only, come paper_trend per TP01), per validare +l'esecuzione cross-venue a rischio zero prima di qualunque capitale reale. diff --git a/scripts/research/eq_tp01_gtaa_combo.py b/scripts/research/eq_tp01_gtaa_combo.py new file mode 100644 index 0000000..dcd20c5 --- /dev/null +++ b/scripts/research/eq_tp01_gtaa_combo.py @@ -0,0 +1,93 @@ +"""COMBO DEPLOYABLE — TP01 (Deribit) + GTAA (IB): le DUE gambe realmente eseguibili a basso capitale. + +Il combo crypto-pieno (TP01+XS01+VRP01)+GTAA diversificava (Sharpe 1.6->1.8), ma XS01/VRP01 sono +STAT-MODE (non eseguibili a $600). Qui il combo ONESTO/deployable: solo le gambe eseguibili — + * TP01: TSMOM difensivo BTC/ETH, long-flat, gia' ARMATO live su Deribit; + * GTAA: trend difensivo multi-asset su ETF, eseguibile su IB (frazioni, switch mensile). +Domanda: due trend difensivi su mercati diversi, scorrelati, danno un blend migliore di ciascuno? + +ALLINEAMENTO: TP01 e' calendario-giornaliero (crypto 7gg), GTAA giorni di borsa -> compoundo TP01 sul +grid dei giorni di borsa (cattura i weekend). Finestra = era TP01 (BTC/ETH dal 2019). +Confronto anche col combo crypto-pieno per quantificare il COSTO della deployability. +""" +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 eq_sector_momentum import _sh, _cagr, _dd, EQ_HOLDOUT +from eq_gtaa_trend import gtaa +from eq_crypto_combo import compound_to_grid, _ann_vol +from src.portfolio.sleeves import _tp01_returns, active_sleeves +from src.portfolio.portfolio import StrategyPortfolio + +ANN = np.sqrt(252.0) + + +def _stat(nm, r): + print(f" {nm:26} Sh {_sh(r):>5.2f} CAGR {_cagr(r.values,r.index)*100:>5.1f}% " + f"volAnn {_ann_vol(r)*100:>4.1f}% maxDD {_dd(r.values)*100:>4.0f}%") + + +def main(): + print("=" * 96) + print(" COMBO DEPLOYABLE — TP01 (Deribit) + GTAA (IB)") + print("=" * 96) + tp01 = _tp01_returns() + if tp01.index.tz is None: + tp01.index = tp01.index.tz_localize("UTC") + eq = gtaa(target_vol=0.12).dropna() + grid = eq.index[eq.index >= tp01.index[0]] + tp = compound_to_grid(tp01, grid) + J = pd.concat({"tp01": tp, "gtaa": eq.reindex(tp.index)}, axis=1).dropna() + print(f" finestra comune {J.index[0].date()}..{J.index[-1].date()} ({len(J)} giorni di borsa, ~{len(J)//252}y)\n") + t, g = J["tp01"], J["gtaa"] + + print(" --- STANDALONE (finestra comune) ---") + _stat("TP01 (crypto, Deribit)", t) + _stat("GTAA vt12 (equity, IB)", g) + c = t.corr(g) + print(f"\n --- CORRELAZIONE TP01 <-> GTAA = {c:+.3f} ---") + + print("\n --- BLEND (capitale) ---") + print(f" {'mix':20} {'Sharpe':>7} {'CAGR%':>6} {'volAnn%':>7} {'maxDD%':>6}") + best = (-9, None) + for wt in (1.0, 0.75, 0.6, 0.5, 0.4, 0.25, 0.0): + b = wt * t + (1 - wt) * g + if _sh(b) > best[0]: + best = (_sh(b), wt) + print(f" TP01 {int(wt*100):>3}/{int((1-wt)*100):<3} GTAA {_sh(b):>7.2f} {_cagr(b.values,b.index)*100:>6.1f} {_ann_vol(b)*100:>7.1f} {_dd(b.values)*100:>6.0f}") + + vt, vg = _ann_vol(t), _ann_vol(g) + wt_rp = (1/vt) / (1/vt + 1/vg) + b_rp = wt_rp * t + (1 - wt_rp) * g + print(f"\n --- RISK-PARITY (inv-vol: TP01 {wt_rp*100:.0f}% / GTAA {(1-wt_rp)*100:.0f}%) ---") + _stat("risk-parity blend", b_rp) + + # OOS (post-2023, per dare un taglio fuori dai primi anni TP01) + cut = pd.Timestamp("2023-01-01", tz="UTC") + print(f"\n --- robustezza: blend 50/50 per taglio ---") + b50 = 0.5 * t + 0.5 * g + for lbl, sub in (("full", b50), (">=2023", b50[b50.index >= cut])): + print(f" {lbl:10} Sh {_sh(sub):.2f} maxDD {_dd(sub.values)*100:.0f}%") + print(" Sharpe 50/50 per anno:", {y: round(_sh(b50[b50.index.year == y]), 2) for y in sorted(set(b50.index.year))}) + + # VERDETTO + costo della deployability + best_solo = max(_sh(t), _sh(g)) + print(f"\n --- VERDETTO ---") + print(f" miglior standalone {best_solo:.2f} | blend 50/50 {_sh(b50):.2f} | risk-parity {_sh(b_rp):.2f} | " + f"miglior cap-mix {best[0]:.2f} (TP01 {int(best[1]*100)}%)") + print(f" -> {'DIVERSIFICA (blend > solo)' if max(_sh(b50),_sh(b_rp)) > best_solo + 0.03 else 'nessun guadagno netto'}") + # costo vs combo crypto-pieno + full = StrategyPortfolio(active_sleeves()).combined_daily() + if full.index.tz is None: full.index = full.index.tz_localize("UTC") + fc = compound_to_grid(full, J.index) + Jf = pd.concat({"f": fc, "g": g.reindex(fc.index)}, axis=1).dropna() + print(f" costo deployability: blend 50/50 con crypto-PIENO Sh {_sh(0.5*Jf['f']+0.5*Jf['g']):.2f} " + f"vs deployable {_sh(b50):.2f} (la differenza = cio' che lasciano XS01/VRP01 STAT-MODE)") + print(f" (cross-venue Deribit+IB; entrambe switch mensile/basso turnover; frazionabili a $0.5-2k)") + + +if __name__ == "__main__": + main()