research(goal50): matematica onesta del target 50eur/g + gate deploy pre-registrato statarb
- r0724_goal50_math: muro capitale (73-228k), leva=rovina, Monte Carlo prop-firm sui ritorni reali del book (P(pass) 56-86%, funded 100k mediana 31-42eur/g), vault TVL 1-2M. Unica via 'da mesi' = moltiplicare nozionale gestito. - r0724_statarb_deploy_gate: regola di deploy PRE-REGISTRATA a fwd-day 25 (decisione 2026-09-27, Sh>=0.5, haircut<0.5pp, 1 proroga max) — anti selection-on-forward. - diario roadmap (sezioni web-research da completare). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Adriano Dal Pastro
@@ -0,0 +1,196 @@
|
||||
"""r0724_goal50_math — la matematica ONESTA del target 50 EUR/giorno (2026-07-24).
|
||||
|
||||
Domanda del goal: "rendita aggiuntiva che entro qualche mese arrivi a 50 EUR/giorno".
|
||||
Questo script NON cerca un edge nuovo: quantifica le vie possibili col book che ABBIAMO,
|
||||
usando i rendimenti giornalieri REALI del book Deribit (TP01 0.75 + SKH01 0.25) e
|
||||
scenari de-luckati. Quattro parti:
|
||||
|
||||
A) IL MURO — capitale richiesto per 50 EUR/g ai CAGR onesti; tempo da 600$ con depositi.
|
||||
B) LA LEVA NON E' LA SCORCIATOIA — vol/DD implicati dal target su capitale piccolo.
|
||||
C) PROP-FIRM EVAL — Monte Carlo (block bootstrap dei ritorni reali del book) di una
|
||||
evaluation tipo crypto-prop: P(pass), giorni mediani, poi fase funded su 100k$:
|
||||
distribuzione EUR/giorno e P(perdere il conto entro 1 anno).
|
||||
D) VAULT / COPY — TVL necessario per 50 EUR/g a perf-share 10%.
|
||||
|
||||
Onesta': i ritorni del book sono MODELLATI (il path live SKH01 e' peggiore: FULL 1.19/
|
||||
HOLD 1.15/DD~25% vs modellato ~1.4-1.6) -> ogni scenario gira anche con haircut sul
|
||||
drift (x0.6) per il de-luck. EURUSD assunto 1.09 (parametro).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from src.portfolio.portfolio import StrategyPortfolio, metrics # noqa: E402
|
||||
from src.portfolio.sleeves import deribit_book_sleeves # noqa: E402
|
||||
|
||||
EURUSD = 1.09 # 1 EUR = 1.09 USD (assunzione dichiarata)
|
||||
TARGET_EUR_DAY = 50.0
|
||||
TARGET_EUR_YR = TARGET_EUR_DAY * 365
|
||||
TARGET_USD_YR = TARGET_EUR_YR * EURUSD
|
||||
RNG = np.random.default_rng(724)
|
||||
|
||||
|
||||
def eur_day(usd_yr: float) -> float:
|
||||
return usd_yr / EURUSD / 365.0
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- A
|
||||
def part_a() -> None:
|
||||
print("=" * 100)
|
||||
print(f" A) IL MURO — 50 EUR/g = {TARGET_EUR_YR:,.0f} EUR/anno = ${TARGET_USD_YR:,.0f}/anno")
|
||||
print("=" * 100)
|
||||
print(" capitale richiesto (rendita = capitale x CAGR netto):")
|
||||
for cagr in (0.08, 0.10, 0.15, 0.20, 0.25):
|
||||
cap = TARGET_USD_YR / cagr
|
||||
print(f" CAGR {cagr:>4.0%} -> capitale ${cap:>10,.0f} (~EUR {cap / EURUSD:,.0f})")
|
||||
print("\n tempo per arrivarci da $600 (compounding mensile + deposito mensile, CAGR 15%):")
|
||||
for dep in (0, 500, 1000, 2000, 5000):
|
||||
eq, months = 600.0, 0
|
||||
target_cap = TARGET_USD_YR / 0.15
|
||||
while eq < target_cap and months < 12 * 60:
|
||||
eq = eq * (1 + 0.15) ** (1 / 12) + dep * EURUSD
|
||||
months += 1
|
||||
yrs = months / 12
|
||||
lab = f"{yrs:.1f} anni" if months < 720 else ">60 anni"
|
||||
print(f" deposito EUR {dep:>5}/mese -> {lab}")
|
||||
print("\n VERDETTO A: da $600, 'qualche mese' per compounding NON esiste. Il capitale")
|
||||
print(" proprio arriva al target solo con depositi da migliaia/mese per molti anni.")
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- B
|
||||
def part_b(book: pd.Series) -> None:
|
||||
m = metrics(book)
|
||||
print("\n" + "=" * 100)
|
||||
print(" B) LA LEVA NON E' LA SCORCIATOIA")
|
||||
print("=" * 100)
|
||||
sh = m["sharpe"]
|
||||
vol = book.std() * np.sqrt(365)
|
||||
cagr = (1 + book).prod() ** (365 / len(book)) - 1
|
||||
print(f" book Deribit (TP01 .75 + SKH01 .25) modellato: Sharpe {sh:.2f} vol {vol:.0%} CAGR {cagr:.1%}")
|
||||
for cap_usd in (600, 2000, 5000, 20000):
|
||||
need = TARGET_USD_YR / cap_usd # rendimento annuo richiesto
|
||||
lev = need / max(cagr, 1e-9) # multiplo di leva sul book
|
||||
vol_imp = vol * lev
|
||||
print(f" su ${cap_usd:>6,}: servono {need:>7.0%}/anno -> leva ~{lev:>5.1f}x il book "
|
||||
f"-> vol implicita ~{vol_imp:>6.0%} -> rovina quasi certa" if lev > 3 else
|
||||
f" su ${cap_usd:>6,}: servono {need:>7.0%}/anno -> leva ~{lev:>5.1f}x il book "
|
||||
f"-> vol implicita ~{vol_imp:>6.0%}")
|
||||
print(" VERDETTO B: il target su capitale piccolo implica vol a 3 cifre = rovina.")
|
||||
print(" (Kelly gia' documentato: il book gira a ~0.01-0.27 Kelly a seconda dello sleeve.)")
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- C
|
||||
def _block_bootstrap_paths(r: np.ndarray, n_days: int, n_paths: int, block: int = 20,
|
||||
drift_scale: float = 1.0) -> np.ndarray:
|
||||
"""Percorsi bootstrap a blocchi dai ritorni giornalieri reali del book.
|
||||
|
||||
drift_scale < 1 = haircut de-luck: riduce la media conservando la vol
|
||||
(r' = (r - mu) + mu*scale).
|
||||
"""
|
||||
mu = r.mean()
|
||||
r_adj = (r - mu) + mu * drift_scale
|
||||
n = len(r_adj)
|
||||
n_blocks = int(np.ceil(n_days / block))
|
||||
starts = RNG.integers(0, n - block, size=(n_paths, n_blocks))
|
||||
idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days]
|
||||
return r_adj[idx]
|
||||
|
||||
|
||||
def _simulate_eval(paths: np.ndarray, target: float, max_dd: float, daily_loss: float,
|
||||
trailing: bool, max_days: int) -> dict:
|
||||
"""Simula una evaluation: passa se equity tocca (1+target) prima di violare
|
||||
il max drawdown (statico da 1.0 o trailing dal max) o il daily loss limit."""
|
||||
n_paths, n_days = paths.shape
|
||||
eq = np.cumprod(1 + paths, axis=1)
|
||||
hwm = np.maximum.accumulate(np.maximum(eq, 1.0), axis=1) if trailing else 1.0
|
||||
dd_breach = eq < (hwm * (1 - max_dd) if trailing else (1 - max_dd))
|
||||
dl_breach = paths < -daily_loss
|
||||
fail = dd_breach | dl_breach
|
||||
passed = eq >= 1 + target
|
||||
|
||||
first_fail = np.where(fail.any(axis=1), fail.argmax(axis=1), max_days + 1)
|
||||
first_pass = np.where(passed.any(axis=1), passed.argmax(axis=1), max_days + 1)
|
||||
ok = first_pass < first_fail
|
||||
p_pass = ok.mean()
|
||||
days = np.median(first_pass[ok]) if ok.any() else np.nan
|
||||
return {"p_pass": p_pass, "median_days": days,
|
||||
"p_fail": (first_fail <= np.minimum(first_pass, max_days)).mean()}
|
||||
|
||||
|
||||
def part_c(book: pd.Series) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" C) PROP-FIRM EVALUATION — Monte Carlo sui ritorni REALI del book (block bootstrap 20g)")
|
||||
print("=" * 100)
|
||||
r = book.to_numpy()
|
||||
n_paths, max_days = 20_000, 365
|
||||
|
||||
rules = [
|
||||
("target 8% / DD 10% statico / daily 4%", 0.08, 0.10, 0.04, False),
|
||||
("target 10% / DD 10% statico / daily 5%", 0.10, 0.10, 0.05, False),
|
||||
("target 10% / DD 10% TRAILING / daily 5%", 0.10, 0.10, 0.05, True),
|
||||
]
|
||||
for drift_scale, lab in ((1.0, "book modellato"), (0.6, "de-luck x0.6 (onesto)")):
|
||||
base = _block_bootstrap_paths(r, max_days, n_paths, drift_scale=drift_scale)
|
||||
for lev in (1.0, 1.5, 2.0):
|
||||
paths = base * lev
|
||||
print(f"\n --- {lab}, leva eval x{lev:.1f} (vol ~{book.std() * np.sqrt(365) * lev:.0%}) ---")
|
||||
for name, tgt, dd, dl, tr in rules:
|
||||
res = _simulate_eval(paths, tgt, dd, dl, tr, max_days)
|
||||
d = f"{res['median_days']:.0f}g" if np.isfinite(res["median_days"]) else "n/a"
|
||||
print(f" {name:<44} P(pass entro 1a) {res['p_pass']:>5.1%} mediana {d}")
|
||||
|
||||
# fase funded: 100k, split 80%, anno di ritorni; conto perso se DD>10%
|
||||
print("\n --- fase FUNDED: $100k nozionale, split 80%, orizzonte 1 anno ---")
|
||||
for drift_scale, lab in ((1.0, "book modellato"), (0.6, "de-luck x0.6")):
|
||||
paths = _block_bootstrap_paths(r, 365, n_paths, drift_scale=drift_scale)
|
||||
eq = np.cumprod(1 + paths, axis=1)
|
||||
hwm = np.maximum.accumulate(np.maximum(eq, 1.0), axis=1)
|
||||
blown = (eq < hwm * 0.90) | (paths < -0.05)
|
||||
alive = ~blown.any(axis=1)
|
||||
pnl = (eq[:, -1] - 1) * 100_000 * 0.80
|
||||
pnl_alive = pnl[alive]
|
||||
q = np.percentile(pnl_alive, [10, 50, 90]) if alive.any() else [np.nan] * 3
|
||||
print(f" {lab:<24} P(conto vivo a 1a) {alive.mean():>5.1%} payout se vivo "
|
||||
f"p10/p50/p90: EUR {eur_day(q[0]) :>5.1f} / {eur_day(q[1]):>5.1f} / {eur_day(q[2]):>5.1f} al giorno")
|
||||
print("\n NB: regole reali (consistency, min trading days, no-bot) possono uccidere lo stile")
|
||||
print(" low-frequency — il verdetto finale dipende dalla ricerca web sulle firm 2026.")
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- D
|
||||
def part_d() -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" D) VAULT / COPY-TRADING — perf-share 10% sopra HWM")
|
||||
print("=" * 100)
|
||||
for cagr in (0.10, 0.15, 0.20):
|
||||
tvl = TARGET_USD_YR / (cagr * 0.10)
|
||||
print(f" CAGR {cagr:.0%}: per 50 EUR/g servono ${tvl / 1e6:,.1f}M di TVL altrui")
|
||||
print(" VERDETTO D: TVL a 7 cifre richiede anni di track record pubblico, non mesi.")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
port = StrategyPortfolio(deribit_book_sleeves())
|
||||
book = port.combined_daily().dropna()
|
||||
book = book[book.index >= "2019-03-01"]
|
||||
m = metrics(book)
|
||||
print(f"book Deribit live (modellato): {len(book)} giorni {book.index[0].date()} -> "
|
||||
f"{book.index[-1].date()} Sharpe {m['sharpe']:.2f} maxDD {m['maxdd']:.1%}")
|
||||
part_a()
|
||||
part_b(book)
|
||||
part_c(book)
|
||||
part_d()
|
||||
print("\n" + "=" * 100)
|
||||
print(" SINTESI ONESTA: 50 EUR/g in qualche mese e' fuori portata del capitale proprio.")
|
||||
print(" L'unica via quantificabile in MESI e' moltiplicare il nozionale gestito (prop/")
|
||||
print(" funded), con P(successo) e regole da verificare; tutto il resto e' anni+capitale.")
|
||||
print("=" * 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user