Adriano Dal Pastro
565 lines
36 KiB
Python
565 lines
36 KiB
Python
#!/usr/bin/env python
|
||
"""r0822_growth_policy.py — LA POLITICA DI LEVA, giudicata sul TEMPO invece che sullo Sharpe.
|
||
|
||
LA DOMANDA. `target_vol=20%` per TP01 e' canonico dal 2026-06-19 e non e' mai stato messo in
|
||
discussione **rispetto a un obiettivo di crescita**. E' stato scelto (e ri-confermato: peso 75/25
|
||
tre volte, TP01xDVOL, tranching) sempre con una lente di **Sharpe** o di **drawdown**. Ma
|
||
l'operatore non massimizza lo Sharpe: vuole ~$258k netti il prima possibile. Sono due problemi
|
||
diversi — lo Sharpe e' invariante alla leva, il TEMPO no.
|
||
|
||
Quindi: **quale leva k minimizza il tempo mediano al bersaglio, a parita' di rischio accettato?**
|
||
E cambia se il bersaglio e' $50k invece di $258k?
|
||
|
||
COSA C'E' QUI
|
||
(0) Replica di controllo: il book live, il fattore d'ancora ×0.89 misurato, e i muri pubblicati.
|
||
(1) LA CURVA DI CRESCITA g(k) — dove sta il massimo (Kelly empirico) e da che parte sta il libro.
|
||
(2) SWEEP PRINCIPALE — per ogni k: tempo mediano al bersaglio (CONDIZIONATO, stampato accanto
|
||
alla sua probabilita'), P(entro 10/15/20a), P(rovina), P(DD>30%). Versamenti €0 e €500/mese,
|
||
bersagli $50k e il muro NETTO. Tutto **al netto del fisco d'accumulo** (33% + carry 4a + 0.2%).
|
||
(3) FRONTIERA ISO-ROVINA — la domanda del brief nella sua forma esatta.
|
||
(4) IL GATE CHE CONTA — il massimo di (1) e' calcolato su un campione che non contiene un solo
|
||
giorno peggiore di -3.9%. Stress esplicito: giorno di crash fuori campione + liquidazione
|
||
Deribit. Dove va il massimo quando il rischio che il dataset NON contiene entra nel conto.
|
||
(5) ESEGUIBILITA' — `config/live.json` oggi tiene il nozionale lordo <= 1.00x l'equity, e il
|
||
knob `target_vol` di TP01 NON scala linearmente (leverage cap 2x). Quanto di k e' teorico.
|
||
|
||
ONESTA' (regole del progetto applicate qui):
|
||
· un non-arrivo e' **+infinito**, mai -1 (l'errore del 07/08: con -1 la mediana MIGLIORA quanto
|
||
peggio va la colonna);
|
||
· una mediana condizionata si stampa **sempre** accanto alla sua probabilita';
|
||
· un Monte Carlo ha una **risoluzione**: la riga di testa e' rifatta con un secondo seme e la
|
||
banda e' dichiarata;
|
||
· la rovina non e' l'azzeramento aritmetico (con ritorni moltiplicativi il capitale non tocca
|
||
zero finche' k < 1/|peggior giorno| = 25.4): e' definita e dichiarata sotto.
|
||
|
||
nice -n 19 timeout 900 uv run python scripts/research/r0822_growth_policy.py
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
import numpy as np
|
||
|
||
ROOT = Path(__file__).resolve().parents[2]
|
||
sys.path.insert(0, str(ROOT))
|
||
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
||
|
||
import r0725_capcurve as CC # noqa: E402 macchineria validata (book_series, _boot_paths, survival)
|
||
import r0726_deposits as DP # noqa: E402 deluck_returns() con il ×0.89 MISURATO
|
||
import r0727_tasse as TX # noqa: E402 CARRY_ANNI, PATRIMONIALE
|
||
from r0807_piano_netto import passo_fiscale # noqa: E402 il passo fiscale gia' validato
|
||
|
||
# ------------------------------------------------------------------ parametri dichiarati
|
||
KS = (0.50, 0.75, 1.00, 1.25, 1.50, 2.00, 2.50, 3.50, 5.00, 7.00,
|
||
10.00, 14.00, 18.00, 22.00) # 14 celle: la griglia stretta (<=8x) NON conteneva il
|
||
# massimo -> allargata finche' il massimo e' INTERNO
|
||
KS_STRESS = (1.00, 1.50, 2.00, 3.50, 5.00, 10.00, 18.00) # sottoinsieme per la (4)
|
||
DEPOSITI = (0, 500) # €/mese: nessuno, e il piano dichiarato
|
||
BERSAGLI = {"$50k": 50_000.0, "muro netto": 258_338.0} # r0807_piano_netto (fisco coerente)
|
||
ANNI = 25 # orizzonte di simulazione: 25 come r0726/r0807 (20 troncherebbe
|
||
# la coda della mediana condizionata). Le P si leggono a 10/15/20a.
|
||
N_PATHS = 2_500
|
||
BLOCK = 20
|
||
CHUNK = 500 # RAM: la VPS ha ~3.5 GB liberi e ci girano altri agenti
|
||
SEED = 20260822
|
||
SEED_BIS = 8221 # secondo seme, solo per dichiarare la risoluzione MC
|
||
START = 600.0
|
||
ALIQUOTA = CC.TAX_RATE # 0.33
|
||
PATRIM = TX.PATRIMONIALE # 0.002
|
||
RUIN_MULT = 0.20 # rovina = il moltiplicatore del PATH perde l'80%
|
||
DD_SOGLIA = 0.30
|
||
WIPE = 0.90 # perdita giornaliera >= 90% dell'equity = liquidazione (margine+fee)
|
||
MURO_PUBBL_LORDO = 272_061.0 # r0726_capwall_refresh (convenzione pubblicata)
|
||
|
||
|
||
def sezione(t: str) -> None:
|
||
print("\n" + "=" * 104)
|
||
print(f" {t}")
|
||
print("=" * 104)
|
||
|
||
|
||
# ===========================================================================
|
||
# il motore: una passata, tutte le leve insieme (confronto APPAIATO sugli stessi path)
|
||
# ===========================================================================
|
||
def simula(r: np.ndarray, ks: tuple[float, ...], *, anni: int, dep_eur: float,
|
||
bersagli: dict[str, float], aliquota: float, patrimoniale: float,
|
||
n_paths: int = N_PATHS, seed: int = SEED, start: float = START,
|
||
crash_pct: float = 0.0, crash_p_anno: float = 0.0) -> dict:
|
||
"""Accumulo a leva `k` per ogni k, sugli STESSI path (differenze appaiate).
|
||
|
||
Stato per (path, k). Traccia in parallelo un GEMELLO SENZA VERSAMENTI: il drawdown e la
|
||
rovina si misurano su quello, cosi' sono confrontabili fra colonne con versamenti diversi
|
||
(un bonifico mensile maschera un drawdown senza ridurre il capitale distrutto).
|
||
|
||
`crash_pct`/`crash_p_anno`: giorno di coda FUORI CAMPIONE (sezione 4). Il block bootstrap non
|
||
puo' generare un giorno peggiore del peggiore osservato: se lo si vuole, va messo a mano.
|
||
|
||
Liquidazione: se la perdita del giorno a leva k supera `WIPE` dell'equity, il conto e' chiuso
|
||
dall'exchange -> capitale a 0 (i versamenti successivi ripartono da li').
|
||
"""
|
||
kv = np.asarray(ks, float)[None, :]
|
||
nk = len(ks)
|
||
dep = dep_eur * CC.EURUSD
|
||
n_days = int(anni * 365)
|
||
rng = np.random.default_rng(seed)
|
||
nomi = list(bersagli)
|
||
soglie = np.array([bersagli[n] for n in nomi], float)
|
||
|
||
hit = {n: [] for n in nomi}
|
||
fin, mult_fin, ruin, ddmax, versato_tot = [], [], [], [], 0.0
|
||
|
||
for c0 in range(0, n_paths, CHUNK):
|
||
m = min(CHUNK, n_paths - c0)
|
||
paths = CC._boot_paths(r, m, n_days, BLOCK, rng)
|
||
if crash_pct > 0 and crash_p_anno > 0:
|
||
# un giorno di crash con probabilita' `crash_p_anno`/anno, uniforme nel tempo
|
||
p_giorno = crash_p_anno / 365.0
|
||
mask = rng.random((m, n_days)) < p_giorno
|
||
paths = np.where(mask, -abs(crash_pct), paths)
|
||
|
||
cap = np.full((m, nk), start, float)
|
||
mult = np.ones((m, nk), float) # gemello senza versamenti
|
||
hwm = np.ones((m, nk), float)
|
||
dd = np.zeros((m, nk), float)
|
||
rovinato = np.zeros((m, nk), bool)
|
||
colpito = {n: np.full((m, nk), np.inf) for n in nomi}
|
||
carry = np.zeros((m * nk, TX.CARRY_ANNI))
|
||
anno_start = cap.copy()
|
||
flusso = np.zeros((m, nk))
|
||
versato = start
|
||
|
||
for t in range(n_days):
|
||
rt = paths[:, t][:, None] * kv # (m, nk)
|
||
liq = rt <= -WIPE
|
||
g = np.where(liq, -1.0, rt)
|
||
cap *= (1.0 + g)
|
||
cap = np.maximum(cap, 0.0)
|
||
mult *= (1.0 + g)
|
||
mult = np.maximum(mult, 0.0)
|
||
hwm = np.maximum(hwm, mult)
|
||
dd = np.maximum(dd, 1.0 - mult / hwm)
|
||
rovinato |= mult <= RUIN_MULT
|
||
if dep > 0 and t % 30 == 0 and t > 0:
|
||
cap += dep
|
||
flusso += dep
|
||
versato += dep
|
||
for j, n in enumerate(nomi):
|
||
nuovi = np.isinf(colpito[n]) & (cap >= soglie[j])
|
||
colpito[n][nuovi] = t
|
||
if (t + 1) % 365 == 0 and (aliquota > 0 or patrimoniale > 0):
|
||
passo_fiscale(cap.ravel(), anno_start.ravel(), flusso.ravel(),
|
||
carry, aliquota, patrimoniale)
|
||
anno_start = cap.copy()
|
||
flusso[:] = 0.0
|
||
|
||
for n in nomi:
|
||
hit[n].append(colpito[n])
|
||
fin.append(cap)
|
||
mult_fin.append(mult)
|
||
ruin.append(rovinato)
|
||
ddmax.append(dd)
|
||
versato_tot = versato
|
||
|
||
out = dict(versato=versato_tot, anni=anni, n_paths=n_paths, ks=ks)
|
||
out["cap"] = np.concatenate(fin, axis=0)
|
||
out["mult"] = np.concatenate(mult_fin, axis=0)
|
||
out["ruin"] = np.concatenate(ruin, axis=0)
|
||
out["dd"] = np.concatenate(ddmax, axis=0)
|
||
out["hit"] = {n: np.concatenate(hit[n], axis=0) for n in nomi}
|
||
return out
|
||
|
||
|
||
def anni_cond(hit_col: np.ndarray) -> tuple[float, float, float, float]:
|
||
"""(anni mediani CONDIZIONATI all'arrivo, P<=10a, P<=15a, P<=20a). Non-arrivo = +inf."""
|
||
arr = hit_col[np.isfinite(hit_col)]
|
||
med = float(np.median(arr)) / 365.0 if len(arr) >= 50 else float("nan")
|
||
p = lambda y: float((hit_col <= y * 365).mean()) # noqa: E731
|
||
return med, p(10), p(15), p(20)
|
||
|
||
|
||
def fmt_anni(a: float) -> str:
|
||
return f"{a:.1f}a" if np.isfinite(a) else "mai"
|
||
|
||
|
||
# ===========================================================================
|
||
def main() -> None:
|
||
print("=" * 104)
|
||
print(" r0822 — GROWTH POLICY: quale leva minimizza il TEMPO al bersaglio, a pari rovina accettata")
|
||
print("=" * 104)
|
||
|
||
# ------------------------------------------------------------------ (0)
|
||
sezione("(0) IL DATO — book LIVE (TP01 75 / SKH01 25) e replica di controllo")
|
||
base = CC.book_series("hourly")
|
||
r = DP.deluck_returns()
|
||
print(f"\n serie: {len(base)} giorni, {base.index.min().date()} -> {base.index.max().date()}")
|
||
print(f" lente 'hourly' = SKH01 sul PATH LIVE (fill al close 5m orario), non il backtest.")
|
||
print(f" canonico : drift {base.values.mean()*365:>7.2%} vol {base.values.std()*365**0.5:>6.2%}"
|
||
f" Sharpe {base.values.mean()/base.values.std()*365**0.5:>5.2f}")
|
||
print(f" de-luckato ×{DP.DELUCK}: drift {r.mean()*365:>7.2%} vol {r.std()*365**0.5:>6.2%}"
|
||
f" Sharpe {r.mean()/r.std()*365**0.5:>5.2f} <-- questa e' la serie usata ovunque sotto")
|
||
print(f" peggior giorno {r.min():+.2%} · miglior giorno {r.max():+.2%}")
|
||
print(f"\n ⚠️ Conseguenza aritmetica da tenere a mente per tutto il resto: con ritorni")
|
||
print(f" moltiplicativi il capitale NON tocca zero finche' k < 1/{abs(r.min()):.4f} = "
|
||
f"{1/abs(r.min()):.1f}x.")
|
||
print(f" Percio' 'rovina' qui e' DEFINITA: il moltiplicatore del path (gemello SENZA")
|
||
print(f" versamenti) scende sotto {RUIN_MULT:.0%}, cioe' 4 euro su 5 distrutti. E la")
|
||
print(f" liquidazione dell'exchange e' modellata a parte: perdita giornaliera >= {WIPE:.0%}.")
|
||
print(f"\n muri pubblicati riusati come bersagli:")
|
||
print(f" · ${MURO_PUBBL_LORDO:,.0f} (r0726_capwall_refresh, convenzione LORDA)")
|
||
print(f" · ${BERSAGLI['muro netto']:,.0f} (r0807_piano_netto, fisco COERENTE) <-- usato qui")
|
||
print(f" · $50.000 (il bersaglio 'corto' chiesto dal brief: ~€19/g di rendita perpetua)")
|
||
|
||
print("\n CONTROLLO DI REPLICA — questo motore contro la tabella pubblicata il 07/08")
|
||
print(" (`r0807_piano_netto` §2: stesso fisco, stesso bersaglio, stessa convenzione di")
|
||
print(" mediana condizionata). I path sono diversi: si chiede accordo entro il rumore MC,")
|
||
print(" non l'identita'. Se questa riga non torna, nessun numero nuovo sarebbe")
|
||
print(" distinguibile da un bug.")
|
||
print(f"\n {'EUR/mese':>9}{'anni (pubbl.)':>16}{'P<=20a (pubbl.)':>18}{'anni (qui)':>13}{'P<=20a (qui)':>15}")
|
||
for dep, a_pub, p_pub in ((250, 19.8, 0.52), (500, 14.7, 0.99)):
|
||
sr = simula(r, (1.00,), anni=25, dep_eur=dep, bersagli={"muro": BERSAGLI["muro netto"]},
|
||
aliquota=ALIQUOTA, patrimoniale=PATRIM, n_paths=3_000, seed=725)
|
||
a, _, _, p20 = anni_cond(sr["hit"]["muro"][:, 0])
|
||
print(f" {dep:>9}{a_pub:>15.1f}a{p_pub:>18.0%}{fmt_anni(a):>13}{p20:>15.0%}")
|
||
|
||
# ------------------------------------------------------------------ (1)
|
||
sezione("(1) LA CURVA DI CRESCITA g(k) — dove sta il massimo, e DI QUANTO il libro ne dista")
|
||
print(f"\n Crescita geometrica MEDIANA annua, orizzonte {ANNI} anni, ZERO versamenti,")
|
||
print(f" {N_PATHS} path, fisco d'accumulo DENTRO. Un vol-target e' esattamente questo:")
|
||
print(" uno scalare sui pesi. Griglia allargata a 22x perche' a 8x il massimo non era")
|
||
print(" ancora interno — una griglia che si ferma prima del massimo non lo misura, lo tronca.")
|
||
s0 = simula(r, KS, anni=ANNI, dep_eur=0, bersagli=BERSAGLI,
|
||
aliquota=ALIQUOTA, patrimoniale=PATRIM, seed=SEED)
|
||
s0b = simula(r, KS, anni=ANNI, dep_eur=0, bersagli=BERSAGLI,
|
||
aliquota=ALIQUOTA, patrimoniale=PATRIM, seed=SEED_BIS)
|
||
mu, sig = float(r.mean()), float(r.std())
|
||
kelly_gauss = mu / sig ** 2
|
||
|
||
def g_curve(sim: dict) -> list[float]:
|
||
return [float(np.median(sim["mult"][:, j])) ** (1 / ANNI) - 1 for j in range(sim["mult"].shape[1])]
|
||
|
||
g_med, g_medb = g_curve(s0), g_curve(s0b)
|
||
jstar = int(np.argmax(g_med))
|
||
kbest, gbest = KS[jstar], g_med[jstar]
|
||
j1 = KS.index(1.00)
|
||
|
||
lg = lambda g: float(np.log1p(g)) # noqa: E731
|
||
print(f"\n {'k':>6}{'g mediana/anno':>17}{'(2° seme)':>12}{'ln(1+g)/ln(1+g*)':>19}"
|
||
f"{'maxDD mediano':>16}{'P(DD>30%)':>11}{'P(rovina)':>11}{'cap mediano a 25a':>20}")
|
||
for j, k in enumerate(KS):
|
||
marca = " <-- LIBRO" if j == j1 else (" <-- k*" if j == jstar else "")
|
||
print(f" {k:>6.2f}{g_med[j]:>17.2%}{g_medb[j]:>12.2%}{lg(g_med[j])/lg(gbest):>19.2f}"
|
||
f"{np.median(s0['dd'][:, j]):>16.1%}{(s0['dd'][:, j] > DD_SOGLIA).mean():>11.1%}"
|
||
f"{s0['ruin'][:, j].mean():>11.1%}{np.median(s0['cap'][:, j]):>20,.0f}{marca}")
|
||
esec = [j for j, k in enumerate(KS) if k <= 2.50]
|
||
ris = max(abs(a - b) for a, b in zip(g_med, g_medb))
|
||
ris_e = max(abs(g_med[j] - g_medb[j]) for j in esec)
|
||
print(f"\n RISOLUZIONE MONTE CARLO (due semi indipendenti a {N_PATHS} path): scarto massimo")
|
||
print(f" {ris:.2%}/anno sull'intera griglia, ma solo {ris_e:.2%}/anno nella regione")
|
||
print(f" k<={KS[esec[-1]]:.2f} — il rumore vive tutto nelle celle a leva alta, dove la mediana e'")
|
||
print(" presa su una distribuzione enormemente dispersa. Conseguenza da tenere: la")
|
||
print(" POSIZIONE del massimo non e' risolvibile a questa taglia (vedi sotto), i confronti")
|
||
print(" nella regione eseguibile si'. Ogni confronto e' APPAIATO (stessi path per ogni k).")
|
||
|
||
print(f"\n RISPOSTA ALLA DOMANDA 'da che parte, e di quanto':")
|
||
print(f" massimo EMPIRICO della crescita k* = {kbest:.2f}x (g = {gbest:.1%}/anno)")
|
||
print(f" massimo GAUSSIANO (Kelly, mu/sigma²) k = {kelly_gauss:.1f}x")
|
||
print(f" il LIBRO gira a k = 1.00x (g = {g_med[j1]:.1%}/anno)")
|
||
print(f" -> il libro sta a SINISTRA, a {1.0/kbest:.0%} di Kelly empirico, e raccoglie il")
|
||
print(f" {lg(g_med[j1])/lg(gbest):.0%} della crescita massima (in crescita LOGARITMICA, che e' la")
|
||
print(" grandezza che Kelly massimizza). NON e' un plateau: e' il ramo ripido.")
|
||
print(f"\n ⚠️ La POSIZIONE del massimo non e' risolta a questa taglia: la sezione (4) rifa'")
|
||
print(" la stessa curva con 1500 path e il massimo cade a 10x invece di 14x. La regione")
|
||
print(" 8-14x e' piatta entro il rumore -> si cita 'k* ~ 10-14x', non un numero.")
|
||
print(" Cio' che E' risolto, e con margine enorme, e' che 1.00x non ci sta vicino.")
|
||
print(f"\n ⚠️ PREVISIONE MIA, REFUTATA IN SESSIONE. Mi aspettavo che il massimo empirico")
|
||
print(f" cadesse molto a SINISTRA di quello gaussiano ({kelly_gauss:.1f}x), perche' il bootstrap a")
|
||
print(" blocchi conserva code e clustering che la formula ignora. Non succede: i due")
|
||
print(" coincidono entro il rumore. Il motivo e' informativo e prepara la sezione (4) —")
|
||
print(" la distribuzione delle CHIUSURE giornaliere di questo libro non ha code abbastanza")
|
||
print(" spesse da spostare Kelly. Il rischio che conta a leva non e' in quella")
|
||
print(" distribuzione, quindi non lo si trovera' ricampionandola meglio.")
|
||
print(f"\n ⚠️ Questo e' il risultato della lente, non una raccomandazione. Tre cose lo")
|
||
print(" ridimensionano, e sono misurate sotto: (a) k* dipende dal DRIFT, che e' stimato")
|
||
print(f" su {len(r)/365:.1f} anni (sez. 1-bis); (b) la coda che lo sostiene NON e' nel")
|
||
print(" campione (sez. 4); (c) meta' della griglia non e' eseguibile (sez. 5).")
|
||
print(f" ⚠️ E c'e' un controllo di plausibilita' che il modello fallisce da solo: a k={KS[jstar]:g}x")
|
||
print(f" il capitale mediano a 25 anni partendo da $600 e' ${np.median(s0['cap'][:, jstar]):,.0f}.")
|
||
print(" Un modello che promette piu' della capitalizzazione del mercato in cui trada ha")
|
||
print(" lasciato il dominio in cui vuol dire qualcosa: assume che il ritorno sia")
|
||
print(" indipendente dalla SIZE, il che e' falso ben prima di quella cifra.")
|
||
|
||
# ------------------------------------------------------------------ (1-bis)
|
||
sezione("(1-bis) QUANTO E' SOLIDO k* — Kelly e' ipersensibile al drift, e il drift e' una STIMA")
|
||
se_drift = float(r.std() * 365 ** 0.5) / (len(r) / 365) ** 0.5
|
||
print(f"\n drift stimato {mu*365:.2%}/anno su {len(r)/365:.1f} anni con vol {r.std()*365**0.5:.2%}")
|
||
print(f" -> errore standard della MEDIA = vol/sqrt(T) = {se_drift:.2%}/anno.")
|
||
print(" Kelly va come mu/sigma²: e' LINEARE nell'errore del drift, quindi l'incertezza")
|
||
print(" sul numeratore si trasferisce intera su k*. Stessa macchineria di `deluck_returns`")
|
||
print(" (si sottrae una costante al drift, la vol resta quella misurata).")
|
||
print(f"\n {'ipotesi sul drift':>34}{'drift/anno':>13}{'k* gaussiano':>15}{'k* empirico':>14}"
|
||
f"{'g(1x)':>9}{'g(k*)':>9}")
|
||
scen = [("punto (de-luckato ×0.89)", 0.0),
|
||
("-1 errore standard", se_drift),
|
||
("-2 errori standard", 2 * se_drift),
|
||
("drift dimezzato (lente 07/08)", mu * 365 / 2),
|
||
("drift a zero", mu * 365)]
|
||
for nome, taglio in scen:
|
||
rs = r - taglio / 365.0
|
||
mus = float(rs.mean())
|
||
kg = mus / sig ** 2
|
||
ss = simula(rs, KS, anni=ANNI, dep_eur=0, bersagli=BERSAGLI, aliquota=ALIQUOTA,
|
||
patrimoniale=PATRIM, seed=SEED, n_paths=1_500)
|
||
gs = g_curve(ss)
|
||
js = int(np.argmax(gs))
|
||
print(f" {nome:>34}{mus*365:>13.2%}{kg:>15.1f}{KS[js]:>13.2f}x"
|
||
f"{gs[j1]:>9.1%}{gs[js]:>9.1%}")
|
||
print("\n Lettura: un errore di stima di UN solo errore standard sul drift — che a 7 anni di")
|
||
print(" storia e' l'ordine di grandezza normale — sposta k* di parecchie unita'. E' la")
|
||
print(" ragione classica per cui si opera a una FRAZIONE di Kelly: non prudenza morale, ma")
|
||
print(" il fatto che k* e' un numero stimato con una barra d'errore larga quanto se stesso.")
|
||
|
||
# ------------------------------------------------------------------ (2)
|
||
sezione(f"(2) SWEEP PRINCIPALE — tempo al bersaglio, orizzonte {ANNI} anni, AL NETTO del fisco")
|
||
print(f"\n da ${START:.0f} · {N_PATHS} path · blocchi {BLOCK}g · fisco {ALIQUOTA:.0%} + carry "
|
||
f"{TX.CARRY_ANNI}a + patrimoniale {PATRIM:.1%}")
|
||
print(" 'anni' = mediana CONDIZIONATA all'arrivo (non-arrivo = +infinito, MAI -1): si legge")
|
||
print(" sempre insieme a P<=20a accanto. 'p90' = il decile lento, cioe' il rischio di TEMPO.")
|
||
print(" ⚠️ Convenzione dichiarata: il fisco e' dentro il CAPITALE (colonne anni/P), NON dentro")
|
||
print(" il gemello di rischio (colonne DD/rovina). Un drawdown e' un fatto di mercato: metterci")
|
||
print(" l'imposta dentro sommerebbe due cose diverse in un numero solo.")
|
||
risultati = {}
|
||
for dep in DEPOSITI:
|
||
s = s0 if dep == 0 else simula(r, KS, anni=ANNI, dep_eur=dep, bersagli=BERSAGLI,
|
||
aliquota=ALIQUOTA, patrimoniale=PATRIM, seed=SEED)
|
||
risultati[dep] = s
|
||
for nome in BERSAGLI:
|
||
print(f"\n --- versamento €{dep}/mese · bersaglio {nome} (${BERSAGLI[nome]:,.0f}) · "
|
||
f"versato in {ANNI}a ${s['versato']:,.0f} ---")
|
||
print(f" {'k':>6}{'anni (p50)':>13}{'anni (p90)':>13}{'P<=10a':>9}{'P<=15a':>9}"
|
||
f"{'P<=20a':>9}{'P(rovina)':>11}{'P(DD>30%)':>11}{'P(DD>50%)':>11}")
|
||
for j, k in enumerate(KS):
|
||
h = s["hit"][nome][:, j]
|
||
a, p10, p15, p20 = anni_cond(h)
|
||
arr = h[np.isfinite(h)]
|
||
a90 = float(np.percentile(arr, 90)) / 365.0 if len(arr) >= 50 else float("nan")
|
||
print(f" {k:>6.2f}{fmt_anni(a):>13}{fmt_anni(a90):>13}{p10:>9.1%}{p15:>9.1%}"
|
||
f"{p20:>9.1%}{s['ruin'][:, j].mean():>11.1%}"
|
||
f"{(s['dd'][:, j] > DD_SOGLIA).mean():>11.1%}"
|
||
f"{(s['dd'][:, j] > 0.50).mean():>11.1%}")
|
||
|
||
# ------------------------------------------------------------------ (3)
|
||
sezione("(3) FRONTIERA ISO-ROVINA — la domanda del brief nella sua forma esatta")
|
||
print("\n 'a parita' di probabilita' di rovina accettata': per ogni budget di rischio, la")
|
||
print(" leva PIU' ALTA che lo rispetta, e il tempo che quel budget compra. Il rischio si")
|
||
print(" misura sul gemello SENZA versamenti (deposit-independent: un bonifico mensile")
|
||
print(" maschera un drawdown senza ridurre il capitale distrutto), ed e' la stessa")
|
||
print(" grandezza su cui passa la regola di DD per-conto del canale funded.")
|
||
for dep in DEPOSITI:
|
||
s = risultati[dep]
|
||
print(f"\n --- versamento €{dep}/mese ---")
|
||
print(f" {'budget':>8}{'metrica':>13}{'k max':>9}"
|
||
+ "".join(f"{'anni ' + n:>22}" for n in BERSAGLI))
|
||
for metrica, col in (("P(DD>30%)", lambda j: (s["dd"][:, j] > DD_SOGLIA).mean()),
|
||
("P(rovina)", lambda j: s["ruin"][:, j].mean())):
|
||
for budget in (0.01, 0.05, 0.10, 0.25, 0.50):
|
||
amm = [j for j in range(len(KS)) if col(j) <= budget]
|
||
if not amm:
|
||
print(f" {budget:>7.0%}{metrica:>13}{'nessuna':>9}")
|
||
continue
|
||
j = max(amm)
|
||
celle = []
|
||
for n in BERSAGLI:
|
||
a, _, _, p20 = anni_cond(s["hit"][n][:, j])
|
||
celle.append(f"{fmt_anni(a)} (P20 {p20:.0%})")
|
||
print(f" {budget:>7.0%}{metrica:>13}{KS[j]:>8.2f}x" + "".join(f"{c:>22}" for c in celle))
|
||
print("\n ⚠️ Le due metriche danno risposte MOLTO diverse, e la ragione conta: P(rovina)")
|
||
print(" (perdere l'80% del moltiplicatore) e' quasi zero fino a leve altissime perche'")
|
||
print(" il libro non ha mai perso l'80% in nessuna finestra ricampionabile; P(DD>30%)")
|
||
print(" morde subito. Chi sceglie la leva sul solo azzeramento sceglie sulla metrica")
|
||
print(" che il dataset non puo' informare — vedi (4).")
|
||
|
||
# ------------------------------------------------------------------ (4)
|
||
sezione("(4) IL GATE CHE CONTA — k* e' calcolato su un campione senza un solo giorno di crash")
|
||
print(f"\n Il block bootstrap ricampiona i giorni VISSUTI: non puo' produrre un giorno")
|
||
print(f" peggiore di {r.min():.2%}. Il libro ha attraversato il 2022 (LUNA/FTX) restando")
|
||
print(" difensivo — quindi per k=1 la coda del campione e' onesta. Ma a leva il rischio")
|
||
print(" cambia NATURA: entra la liquidazione, che su una chiusura giornaliera non si vede")
|
||
print(" (lezione della lente wick accoppiata, 25/07: 'close-only non e' conservativa, e'")
|
||
print(" CIECA'). Il rischio fuori campione non si stima dal campione: si mette a mano e si")
|
||
print(" dichiara. Ampiezze scelte a priori sull'unico precedente misurato nel progetto:")
|
||
print(" il gap-through-stop di SKH01 (sl 2% modellato -> -11/-23% realizzato).")
|
||
print(f"\n liquidazione se la perdita a leva supera {WIPE:.0%} dell'equity in un giorno.")
|
||
print(f"\n {'scenario':>22}" + "".join(f"{f'k={k:g}':>10}" for k in KS_STRESS) + f"{' k*':>8}")
|
||
s0s = simula(r, KS_STRESS, anni=ANNI, dep_eur=0, bersagli=BERSAGLI, aliquota=ALIQUOTA,
|
||
patrimoniale=PATRIM, seed=SEED, n_paths=1_500)
|
||
g0s = [float(np.median(s0s["mult"][:, j])) ** (1 / ANNI) - 1 for j in range(len(KS_STRESS))]
|
||
print(f" {'nessuno stress':>22}" + "".join(f"{g:>10.1%}" for g in g0s)
|
||
+ f"{f'{KS_STRESS[int(np.argmax(g0s))]:g}x':>8}")
|
||
for cpct in (0.10, 0.15, 0.20):
|
||
for panno in (0.20, 1.00):
|
||
ss = simula(r, KS_STRESS, anni=ANNI, dep_eur=0, bersagli=BERSAGLI, aliquota=ALIQUOTA,
|
||
patrimoniale=PATRIM, seed=SEED, crash_pct=cpct, crash_p_anno=panno,
|
||
n_paths=1_500)
|
||
gg = [float(np.median(ss["mult"][:, j])) ** (1 / ANNI) - 1 for j in range(len(KS_STRESS))]
|
||
print(f" {f'-{cpct:.0%} ogni {1/panno:.0f}a':>22}"
|
||
+ "".join(f"{g:>10.1%}" for g in gg)
|
||
+ f"{f'{KS_STRESS[int(np.argmax(gg))]:g}x':>8}")
|
||
print("\n Lettura: basta UN giorno fuori campione all'anno perche' il massimo collassi da")
|
||
print(" due cifre a poche unita', e il ramo destro della curva e' il primo ad andare a")
|
||
print(" -100%. La crescita a leva alta e' comprata vendendo la coda che il dataset non")
|
||
print(" contiene: e' la stessa firma che il gate `implausible_sharpe` cerca (rischio FUORI")
|
||
print(" dal dataset), applicata alla politica invece che alla strategia.")
|
||
|
||
# ------------------------------------------------------------------ (5)
|
||
sezione("(5) ESEGUIBILITA' — quanto di questa griglia esiste davvero sul conto")
|
||
import json
|
||
cfg = json.loads((ROOT / "config" / "live.json").read_text())
|
||
frac = cfg["max_notional_per_asset_frac"]
|
||
lordo_max = frac * 2 # 2 asset (BTC, ETH)
|
||
print(f"\n (a) IL CAP DI CONFIG. max_notional_per_asset_frac = {frac} su 2 asset")
|
||
print(f" -> nozionale LORDO massimo = {lordo_max:.2f}x l'equity. **k > {lordo_max:.2f}x NON e'")
|
||
print(" eseguibile senza toccare `config/live.json`**, e il 26/07 il progetto ha legato")
|
||
print(" una conclusione a quel parametro con un test apposta")
|
||
print(" (`test_leva_massima_da_config_resta_sotto_o_uguale_a_1x`): alzare il cap ROMPE")
|
||
print(" quel test, che e' esattamente il suo scopo. Quindi 11 delle 14 celle di questa")
|
||
print(" griglia sono TEORICHE per costruzione.")
|
||
print(f" min_order ${cfg['min_order_usd']} · disaster-SL {cfg['disaster_sl_pct']:.0%} · "
|
||
f"cap $ {cfg['max_notional_per_asset_usd']:,} (binding: min(quello, equity×{frac}))")
|
||
|
||
print("\n (b) IL KNOB `target_vol` DI TP01 — ipotesi mia: il leverage cap 2x lo strozza.")
|
||
from src.data.downloader import load_data # noqa: E402
|
||
from src.strategies.trend_portfolio import ( # noqa: E402
|
||
CANONICAL, TrendPortfolio, resample_1d, simple_returns)
|
||
import pandas as pd # noqa: E402
|
||
dfs = {a: resample_1d(load_data(a, "1h")) for a in ("BTC", "ETH")}
|
||
def tp01_knob(tv: float, lev: float) -> tuple[float, float, float]:
|
||
"""(vol realizzata annua, Sharpe, quota di barre incollate al leverage cap) del solo TP01
|
||
50/50 BTC-ETH, netto fee, con `target_vol=tv` e `leverage=lev`."""
|
||
serie, atcap = {}, []
|
||
for a, df in dfs.items():
|
||
tp = TrendPortfolio(**{**CANONICAL, "target_vol": tv, "leverage": lev})
|
||
tgt = np.nan_to_num(np.asarray(tp.target_series(df), float))
|
||
ret = simple_returns(df["close"].values.astype(float))
|
||
pos = np.zeros(len(tgt)); pos[1:] = tgt[:-1]
|
||
net = pos * ret - 0.0005 * np.abs(np.diff(pos, prepend=0.0))
|
||
net[0] = 0.0
|
||
serie[a] = pd.Series(net, index=pd.to_datetime(df["datetime"]))
|
||
atcap.append(float((np.abs(tgt) >= lev - 1e-9).mean()))
|
||
J = pd.concat(serie, axis=1, join="inner").fillna(0.0) # le due serie hanno lunghezze
|
||
x = (0.5 * J["BTC"] + 0.5 * J["ETH"]).values # diverse: si allineano sulle date
|
||
return (float(x.std() * 365 ** 0.5), float(x.mean() / x.std() * 365 ** 0.5),
|
||
float(np.mean(atcap)))
|
||
|
||
rif = tp01_knob(0.20, 2.0)[0] # il canonico, calcolato PRIMA di usarlo come riferimento
|
||
print(f"\n {'target_vol':>11}{'lev cap':>9}{'x NOMINALE':>12}{'vol realizz.':>14}"
|
||
f"{'x OTTENUTO':>12}{'Sharpe':>9}{'quota barre al cap':>21}")
|
||
for lev in (2.0, 4.0):
|
||
for tv in (0.10, 0.20, 0.30, 0.40, 0.60):
|
||
v, sh, ac = tp01_knob(tv, lev)
|
||
print(f" {tv:>11.0%}{lev:>9.1f}{tv/0.20:>12.2f}{v:>14.2%}{v/rif:>12.2f}{sh:>9.2f}"
|
||
f"{ac:>21.1%}")
|
||
v20, sh20, _ = tp01_knob(0.20, 2.0)
|
||
print(f"\n ❌ IPOTESI REFUTATA, e la refutazione e' piu' utile dell'ipotesi. 'x OTTENUTO'")
|
||
print(" segue 'x NOMINALE' fino a target_vol 60% (3.00 nominale -> 2.98 ottenuto) e le")
|
||
print(" barre incollate al cap sono l'1.0%: **il leverage cap 2x NON e' binding**, quindi")
|
||
print(" il knob e' uno scalare lineare pulito. Lo Sharpe e' invariante a ogni cella")
|
||
print(f" (1.31 ovunque) — che e' esattamente il punto: la lente con cui `target_vol=20%`")
|
||
print(" fu scelto NON puo' distinguere queste righe, e infatti non le distingue.")
|
||
print(f"\n ⚠️ Sottoprodotto da registrare: a `target_vol=20%` la vol REALIZZATA di TP01 e'")
|
||
print(f" {v20:.2%}, non 20%. Il target vale sulla posizione quando c'e'; TP01 e' long-flat e")
|
||
print(" sta flat una parte del tempo, quindi l'etichetta sovrastima il rischio preso di")
|
||
print(" ~40%. Chi legge '20%' e lo confronta con un altro sistema sta confrontando un")
|
||
print(" parametro con una misura.")
|
||
print("\n Cio' che resta binding e' altro: (i) il cap di nozionale di config, punto (a);")
|
||
print(" (ii) SKH01 (25% del libro) NON e' vol-targeted affatto (misurato 26/07) — li'")
|
||
print(" l'unico modo di alzare la leva e' moltiplicare la size, cioe' margine e")
|
||
print(" liquidazione vere, non un parametro di sizing.")
|
||
|
||
print("\n (c) COSA COSTA LA LEVA E NON E' NEL MODELLO SOPRA (tutti a sfavore di k alto):")
|
||
print(" · la fee scala LINEARMENTE con k (3,5 bps/lato oggi) e SKH01 e' ~4x piu'")
|
||
print(" fee-sensibile di TP01 (curva misurata il 26/07: -0.017 Sharpe/bps di book);")
|
||
print(" · il funding dei perp e il costo del margine oltre 1x non sono modellati;")
|
||
print(" · il min_order $5 su un conto da $635 e la granularita' che ne consegue;")
|
||
print(" · l'impatto: il modello assume ritorno indipendente dalla size (vedi sez. 1).")
|
||
print(" -> i numeri a k>1 sono un TETTO, non una stima.")
|
||
|
||
# ------------------------------------------------------------------ verdetto
|
||
sezione("VERDETTO")
|
||
s500 = risultati[500]
|
||
jj = {k: KS.index(k) for k in (1.00, 1.50, 2.00)}
|
||
righe = []
|
||
for nome in BERSAGLI:
|
||
for k, j in jj.items():
|
||
a, _, _, p20 = anni_cond(s500["hit"][nome][:, j])
|
||
righe.append((nome, k, a, p20, (s500["dd"][:, j] > DD_SOGLIA).mean()))
|
||
print(f"\n A €500/mese (il piano dichiarato), zona ESEGUIBILE e primo passo oltre:")
|
||
print(f" {'bersaglio':>14}{'k':>7}{'anni (p50)':>13}{'P<=20a':>9}{'P(DD>30%)':>11}")
|
||
for nome, k, a, p20, pdd in righe:
|
||
print(f" {nome:>14}{k:>6.2f}x{fmt_anni(a):>13}{p20:>9.0%}{pdd:>11.0%}")
|
||
print(f"""
|
||
GATE — cosa e' girato e cosa no (un gate non girato si dichiara, non si omette):
|
||
· `marginal_vs_tp01` NON APPLICABILE. Non c'e' un flusso di ritorni nuovo da giudicare
|
||
marginalmente: k e' uno SCALARE sul libro esistente, quindi la
|
||
correlazione col baseline e' 1.00 per costruzione.
|
||
· `deflated_sharpe` NON APPLICABILE, e vale la pena dire perche': lo Sharpe e'
|
||
INVARIANTE a k (misurato, sez. 5b: 1.31 a ogni cella del knob).
|
||
Un gate costruito sullo Sharpe da' lo stesso verdetto su tutta la
|
||
griglia — non e' che lo passi, e' che non vede la variabile.
|
||
· null del de-levering NON e' un gate da superare qui: e' L'OGGETTO della misura, percorso
|
||
in entrambi i versi (k<1 e k>1). E lo conferma: ogni 'meno DD' via
|
||
leva e' de-levering per definizione, ogni 'piu' crescita' e' leva.
|
||
· fortuna d'ancora GESTITA col fattore MISURATO ×{DP.DELUCK} sul drift (26/07), non con una
|
||
banda nuova: la leva non ha una propria ancora, moltiplica il drift.
|
||
· `implausible_sharpe` Non girato come funzione (darebbe lo stesso verdetto a ogni k, vedi
|
||
sopra); il controllo di plausibilita' e' stato fatto sull'OUTPUT ed
|
||
e' FALLITO dal modello a leva alta: capitale mediano ${np.median(s0['cap'][:, jstar]):,.0f}
|
||
da $600 in 25 anni. La firma 'rischio fuori dal dataset' c'e', ma
|
||
vive nella POLITICA, non nella strategia.
|
||
· causalita' Ereditata: la serie viene da `CC.book_series('hourly')`, macchineria
|
||
gia' validata; qui non si costruisce nessun segnale nuovo.
|
||
· risoluzione MC DICHIARATA: {ris_e:.2%}/anno nella regione eseguibile, {ris:.2%}/anno sulla
|
||
griglia intera. La posizione del massimo NON e' risolta.
|
||
|
||
1. IL LIBRO STA A SINISTRA DEL MASSIMO, E DI MOLTO: k* empirico ~10-14x (banda, non un
|
||
numero: a 1500 path cade a 10x, a 2500 a {kbest:.0f}x), il libro gira a 1x = {1.0/kbest:.0%} di Kelly
|
||
e raccoglie il {lg(g_med[j1])/lg(gbest):.0%} della crescita massima in log. Non e' un plateau
|
||
(come lo era il peso 75/25): e' il ramo ripido della curva. Sulla lente della CRESCITA
|
||
la scelta canonica `target_vol=20%` non e' ottimale — ed e' un fatto, perche' quella
|
||
scelta fu fatta su una lente di Sharpe, che alla leva e' INVARIANTE.
|
||
|
||
2. MA k* NON E' UN NUMERO SU CUI SI PUO' AGIRE, per tre ragioni misurate qui:
|
||
(a) e' lineare nell'errore del drift, stimato su {len(r)/365:.1f} anni (sez. 1-bis);
|
||
(b) e' comprato vendendo una coda che il dataset NON contiene — un giorno di crash
|
||
all'anno lo riporta a poche unita' (sez. 4);
|
||
(c) 11 celle su 14 non sono eseguibili: il cap di config tiene il nozionale lordo a
|
||
{lordo_max:.2f}x l'equity. (Il knob `target_vol` invece FUNZIONA — misurato, sez. 5b: il
|
||
leverage cap 2x non morde. L'ostacolo e' la config e SKH01, non il sizing di TP01.)
|
||
|
||
3. IL BERSAGLIO CAMBIA LA RISPOSTA, e nel verso opposto a quello che la domanda suggerisce.
|
||
Su $50k a €500/mese la leva quasi non serve: a k=1 ci si arriva in ~5 anni con P=100%,
|
||
perche' fino a quella taglia il capitale lo portano i BONIFICI, non il rendimento
|
||
(misura indipendente del 26/07: al traguardo l'80% viene dal rendimento, ma i primi
|
||
anni no). Sul muro netto la leva morde: e' proprio dove il rischio di rovina diventa
|
||
non-recuperabile, perche' zero e' assorbente e si ricomincia con lo stesso stipendio.
|
||
|
||
4. IL BUCO STRUTTURALE, che e' il risultato piu' trasferibile: **ogni gate di questo
|
||
progetto e' invariante alla leva**. `study_family_honest`, il deflated-Sharpe,
|
||
`marginal_vs_tp01`, `implausible_sharpe`, il null del de-levering, `weights_tilt_null`
|
||
— tutti giudicano forma della distribuzione, correlazioni o PESI RELATIVI, e nessuno
|
||
vede la SCALA. Per questo `target_vol=20%` e' sopravvissuto due mesi di scrutinio
|
||
senza mai essere esaminato: non c'era una lente che potesse bocciarlo.
|
||
|
||
5. COSA RESTA DI OPERATIVO: nulla da cambiare oggi. Il gradino ESEGUIBILE (k da 1.00x a
|
||
1.25-1.50x, cioe' alzare il cap di config) esiste e non e' rumore MC, ma passa per una
|
||
modifica a un file di produzione su un conto con soldi veri, e nessun gate del progetto
|
||
lo autorizza: `weights_tilt_null` giudica i PESI, non la scala, e non esiste un gate
|
||
'politica di leva'. Il candidato naturale sarebbe misurare la stessa curva sul canale
|
||
FUNDED, dove il vincolo binding e' gia' una regola di DD per-conto e il nozionale non
|
||
e' il proprio.
|
||
""")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|