Adriano Dal Pastro
f10d847816
XSR-RENDITA (r0825_xsr_rendita.py): prima valutazione di XSR01 sul criterio della perpetua. A iso-nozionale alza il muro; a iso-rischio lo abbassa del 20,6% MA il null mostra che il meccanismo vale 0,8% (mescolare i rendimenti non cambia nulla) e un conto remunerato allo stesso tasso lo eguaglia a vol zero senza secondo venue. A drift zero il muro SALE: si compra un drift scorrelato, non la scorrelazione. L'haircut non pareggia un conto al 4% nemmeno a zero. Vincolo binding: capitale ($60k per un 25% sopra C*). Corretta in CLAUDE.md la riga Sharpe 1,82 (terza lente; la lente dei gate da' 1,79 alla scoperta / 1,56-1,63 a oggi). VERSAMENTO-3K (r0825_versamento_3k.py): $2.065 -> $5.065 appaiato sugli stessi path del piano = 5,5 mesi di versamenti anticipati; 10a $114.929 -> $122.491 (+6,6%); $15k in 1,3a e $20k in 1,9a. P(cap >= $5k al gate XSR01 del 23/10): 0% -> 100% -- il lump rende il gate leggibile senza rendere XSR01 comprabile: la decisione sulle soglie (S5.3) va presa PRIMA che il lump atterri. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B9UyJLHzR7EJzxR3iQ3RN1
160 lines
8.5 KiB
Python
160 lines
8.5 KiB
Python
"""r0825_versamento_3k.py — cosa compra un versamento di $3.000 ADESSO, dal conto vero.
|
||
|
||
DOMANDA (operatore, 2026-08-25 sera): *"rianalizza e vediamo come procedere. potrei versare a
|
||
breve altri 3k"*. Il conto passerebbe da ~$2.065 a ~$5.065 — esattamente a cavallo della soglia
|
||
$5k su cui sta scritto il criterio di capitale del gate XSR01 (23/10), e a un terzo del muro
|
||
$15-20k che e' insieme il C* vero di Hyperliquid E la soglia della decisione vincolante
|
||
"100% Deribit fino a $20k" (26/07).
|
||
|
||
ASSUNZIONI DICHIARATE:
|
||
- "3k" = 3.000 USDC = $3.000 (i versamenti precedenti dell'operatore sono in USDC);
|
||
- il lump atterra OGGI. "A breve" puo' voler dire fra settimane: ritardarlo di un mese sposta
|
||
i numeri di poco e sempre nello stesso verso (un po' meno beneficio). Non lo modello.
|
||
- equity di partenza: 2.065,00 — letta dal watermark alle 18:47:13Z di oggi (l'istante
|
||
dell'evento, non l'istante della scrittura).
|
||
|
||
LENTE: L3 CONGIUNTA (funding esatto + fisco d'accumulo + ancora de-luckata), la stessa di
|
||
`r0825_piano_10a_500` — stessi semi, stessi path: ogni confronto qui e' APPAIATO (M22).
|
||
⚠️ Stessi difetti ereditati e dichiarati la': 121 versamenti in 10 anni, `versato` scalare.
|
||
⚠️ M23: N_PATHS 3000, blocchi 20g. La banda del muro resta [$187k – $1,14M]: i numeri assoluti
|
||
qui sotto stanno sulla lente `hourly`+L3 e vanno letti con quella etichetta (P7).
|
||
|
||
uv run python scripts/research/r0825_versamento_3k.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
|
||
import r0807_piano_netto as PN # noqa: E402
|
||
import r0822d_piano_vero as PV # noqa: E402
|
||
import r0823_deposit_timing as DT # noqa: E402
|
||
|
||
START_OGGI = 2065.00 # watermark 2026-08-25T18:47:13Z
|
||
LUMP_USD = 3000.0 # il versamento ipotizzato, in USD
|
||
START_LUMP = START_OGGI + LUMP_USD
|
||
DEP = 500.0 # EUR/mese, il piano dichiarato
|
||
ORIZZONTI = (5, 10, 15, 20)
|
||
N_PATHS = 3000
|
||
SEED = PV.SEED_TRAJ
|
||
BLOCK = PV.BLOCK
|
||
GATE_XSR = 59 # giorni da oggi al 2026-10-23 (25/08 -> 23/10)
|
||
MILESTONE = (5_000.0, 15_000.0, 20_000.0) # criterio gate · C* Hyperliquid · muro "100% Deribit"
|
||
|
||
|
||
def sez(t: str) -> None:
|
||
print(f"\n{'='*100}\n {t}\n{'='*100}")
|
||
|
||
|
||
def eur_g(cap: np.ndarray, perp: float) -> np.ndarray:
|
||
return cap * perp / 365.0 / CC.EURUSD
|
||
|
||
|
||
def main() -> None:
|
||
print("=" * 100)
|
||
print(f" r0825 — IL VERSAMENTO DA $3.000: ${START_OGGI:,.0f} -> ${START_LUMP:,.0f}")
|
||
print("=" * 100)
|
||
|
||
B = PV.costruisci_serie()
|
||
r = PV.deluck(B["fund"].values.astype(float))
|
||
lente = PV.Lente("L3 congiunta", r, lordizza=False)
|
||
lente.perp, lente.muro = PV.muro_di(lente)
|
||
print(f"\n lente L3: drift {lente.drift:.2%} · vol {lente.vol:.2%} · perpetua {lente.perp:.2%}"
|
||
f" · muro ${lente.muro:,.0f}")
|
||
|
||
# ---------------------------------------------------- (1) cosa compra il lump, appaiato
|
||
sez(f"(1) COSA COMPRA IL LUMP — €{DEP:.0f}/mese, stessi path, da ${START_OGGI:,.0f} vs "
|
||
f"${START_LUMP:,.0f}")
|
||
print(f" {'oriz.':>6} {'senza lump':>13} {'con lump':>13} {'guadagno':>10} "
|
||
f"{'€/g senza':>11} {'€/g con':>9} {'P(50) senza':>12} {'P(50) con':>10}")
|
||
print(" " + "-" * 92)
|
||
d10 = {}
|
||
for anni in ORIZZONTI:
|
||
rng = np.random.default_rng(SEED)
|
||
ii = DT.boot_idx(len(r), N_PATHS, anni * 365, BLOCK, rng)
|
||
paths = r[ii]
|
||
a = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_OGGI)
|
||
b = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_LUMP)
|
||
ea, eb = eur_g(a["cap"], lente.perp), eur_g(b["cap"], lente.perp)
|
||
pa, pb = float((ea >= 50).mean()), float((eb >= 50).mean())
|
||
if anni == 10:
|
||
d10 = dict(a=a, b=b, ea=ea, eb=eb, pa=pa, pb=pb)
|
||
print(f" {anni:>4}a ${np.median(a['cap']):>11,.0f} ${np.median(b['cap']):>11,.0f} "
|
||
f"{np.median(b['cap'])/np.median(a['cap'])-1:>9.1%} {np.median(ea):>10.2f} "
|
||
f"{np.median(eb):>8.2f} {pa:>11.1%} {pb:>9.1%}")
|
||
lump_in_mesi = LUMP_USD / CC.EURUSD / DEP
|
||
print(f"\n il lump equivale a {lump_in_mesi:.1f} mesi di versamenti anticipati in un colpo.")
|
||
print(f" N3: la leva 'versare' resta la prima — questo lump E' quella leva, esercitata.")
|
||
|
||
# ---------------------------------------------------- (2) pietre miliari
|
||
sez("(2) QUANDO ARRIVANO LE PIETRE MILIARI (€500/mese, primo passaggio, 10 anni di path)")
|
||
rng = np.random.default_rng(SEED)
|
||
ii = DT.boot_idx(len(r), N_PATHS, 10 * 365, BLOCK, rng)
|
||
paths10 = r[ii]
|
||
print(f" {'soglia':>9} {'cosa sblocca':<44} {'senza lump':>11} {'con lump':>9}")
|
||
print(" " + "-" * 82)
|
||
naming = {5_000: "criterio di capitale del gate XSR01",
|
||
15_000: "C* vero di Hyperliquid (pavimento misurato)",
|
||
20_000: "decisione '100% Deribit fino a $20k' si riapre"}
|
||
for ms in MILESTONE:
|
||
riga = []
|
||
for st in (START_OGGI, START_LUMP):
|
||
out = PN.accumula(paths10, DEP, ms, lente.aliq, lente.patr, start=st)
|
||
if st >= ms:
|
||
riga.append("gia' li'")
|
||
continue
|
||
d = PV.leggi(out["colpito"], anni_sim=10)
|
||
riga.append("oltre 10a" if not np.isfinite(d["med"]) else f"{d['med']:.1f}a")
|
||
print(f" ${ms:>7,.0f} {naming[int(ms)]:<44} {riga[0]:>11} {riga[1]:>9}")
|
||
|
||
# ---------------------------------------------------- (3) il gate del 23/10
|
||
sez(f"(3) GATE XSR01 (2026-10-23, fra {GATE_XSR} giorni) — P(capitale >= $5.000 quel giorno)")
|
||
rng = np.random.default_rng(SEED)
|
||
ii = DT.boot_idx(len(r), N_PATHS, GATE_XSR, BLOCK, rng)
|
||
pg = r[ii]
|
||
for st, nome in ((START_OGGI, "senza lump"), (START_LUMP, "con lump")):
|
||
out = PN.accumula(pg, DEP, 5_000.0, lente.aliq, lente.patr, start=st)
|
||
p = float((out["cap"] >= 5_000.0).mean())
|
||
print(f" {nome:<11} start ${st:>7,.0f} -> P(>= $5k al 23/10) = {p:>6.1%} "
|
||
f"(mediana ${np.median(out['cap']):,.0f}, p10 ${np.percentile(out['cap'],10):,.0f})")
|
||
print(f"\n ⚠️ Il criterio FORMALE diventa raggiungibile col lump — ma il C* VERO del venue e'")
|
||
print(f" $15.000-20.000 (§5.3), il 25% a ${START_LUMP:,.0f} sono ${START_LUMP*0.25:,.0f} su")
|
||
print(f" Hyperliquid, e la decisione vincolante del 26/07 dice 100% Deribit fino a $20k.")
|
||
print(f" Il lump rende il gate LEGGIBILE, non rende XSR01 comprabile.")
|
||
|
||
# ---------------------------------------------------- (4) meccanica live a $5.065
|
||
sez(f"(4) COSA CAMBIA NELLA MECCANICA LIVE, DA SOLO, A ${START_LUMP:,.0f}")
|
||
print(f" cap per-asset (equity x 0,5, nessun tetto assoluto sul percorso normale):")
|
||
print(f" ${START_OGGI*0.5:,.0f} -> ${START_LUMP*0.5:,.0f} per asset — nessuna config da toccare,")
|
||
print(f" il profilo di rischio RELATIVO non cambia (leva lorda max resta 1,0x; realizzata")
|
||
print(f" max 0,52x: il vincolo e' il segnale, non il cap)")
|
||
print(f" min_order $5: passa dal {5/(START_OGGI*0.5):.2%} al {5/(START_LUMP*0.5):.2%} del cap")
|
||
print(f" per-asset (C2: un parametro in valuta assoluta pesa meno al crescere del conto)")
|
||
print(f" fallback a equity illeggibile: min($3.000, watermark x 0,5) = "
|
||
f"min(3000, {START_LUMP*0.5:,.0f}) -> ${min(3000.0, START_LUMP*0.5):,.0f}")
|
||
print(f" disaster-SL -30%: invariato — resta rotolante e simmetrico (peggior DD misurato")
|
||
print(f" dall'ingresso -60,6%/-61,5%: il nome inganna anche a $5k)")
|
||
print(f" ⚠️ slip-audit: misurato su fill a $597-2.067; a ${START_LUMP:,.0f} la taglia relativa")
|
||
print(f" raddoppia -> la misura VA RIFATTA dopo i primi fill alla taglia nuova (C2/C5),")
|
||
print(f" lo script c'e' gia' (`r0822_slip_audit.py`, normalizzazione per-fill)")
|
||
|
||
# ---------------------------------------------------- verdetto
|
||
sez("VERDETTO (runtime)")
|
||
med_a, med_b = np.median(d10["a"]["cap"]), np.median(d10["b"]["cap"])
|
||
print(f" a 10 anni con €500/mese: ${med_a:,.0f} -> ${med_b:,.0f} ({med_b/med_a-1:+.1%}), "
|
||
f"€/g {np.median(d10['ea']):.2f} -> {np.median(d10['eb']):.2f}")
|
||
print(f" P(>=50 €/g a 10a): {d10['pa']:.1%} -> {d10['pb']:.1%}")
|
||
print(f" il lump anticipa il piano di ~{lump_in_mesi:.0f} mesi e rende leggibile il gate del")
|
||
print(f" 23/10; NON rende comprabile XSR01 (C* $15-20k) e NON riapre la scelta del venue ($20k).")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|