registro: chiusi §58-69 — dodici verdetti, 0 candidati, e due appoggi tolti a decisioni gia' prese
I dodici filoni della sesta ondata erano rimasti `_in corso_`: la sessione si e' chiusa dopo che gli agenti avevano scritto gli script e prima che i verdetti fossero consolidati, e i loro messaggi finali sono persi. I numeri qui NON vengono da quei messaggi: vengono dalla riesecuzione dei dodici script (07:38-08:06 UTC, sequenziale, log in logs/r0823b/ che e' gitignored). E' il motivo per cui l'ondata non e' andata persa: ogni script calcola il proprio verdetto a runtime. Cosa tocca decisioni gia' prese: - §67 il gate pre-registrato XSR01 del 23/10 legge un monitor tarato sul pavimento del venue sbagliato (C* $15-20k, non ~$3k) - §64 la raccomandazione di §51 (raccogliere la catena USDC) non e' giustificata dalla ragione che porta: le due superfici sono la stessa - §60 la politica MISTO scelta il 25/07 non e' piu' l'ottimo (oggi MISTO-A) - §63 domanda fiscale NUOVA, diversa da quella aperta il 07/08 Il risultato piu' grande e' di §58: l'obiettivo del progetto ha DUE definizioni operative in uso che danno 33,9% contro 0,33% sulla stessa domanda, e non era mai stato detto quale si stesse ottimizzando. r0823b_quasi_passati.py (§68) terminava con IndexError: Griglia.combo() indicizzava con self.idx (2720 giorni) un sottoinsieme di 958 righe. Corretto col parametro idx esplicito piu' un controllo di lunghezza; la rinormalizzazione e' riga per riga, quindi i valori sono quelli dell'intento dell'autore. La correzione e' del coordinatore, non dell'autore, ed e' dichiarata nel registro. Libro, pesi, cron, config INVARIATI. Nessun ordine. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Adriano Dal Pastro
@@ -723,18 +723,18 @@ stessi hanno nominato senza poterli eseguire**. Stesso contratto di consegna, st
|
||||
| 55 | COSTO-CAPITALE | i muri sono calcolati a costo d'esecuzione COSTANTE, ma il costo cresce col capitale: dove sta il muro vero? | **NON MORDE** — il muro si sposta di **+0,6%** (dentro la risoluzione MC), la saturazione sta **30x sopra** ($9,5-10M), e 📌 **alla taglia di oggi il costo mancante ha segno NEGATIVO** |
|
||||
| 56 | XS-AMPIEZZA | su un universo povero (11 gambe), si recupera ampiezza EFFETTIVA senza aggiungere gambe? | **NO — e la caduta NON era ampiezza (solo il 14%)**: e' **selettivita'** (recuperabile ma sotto l'MDE) **piu' un IC che su quelle 11 gambe vale ZERO**. 🚨 E `k=5` **non e' invariante di scala** |
|
||||
| 57 | CRITICO | l'ondata ha prodotto qualcosa che avvicina i 50 EUR/giorno — e i suoi numeri di testa reggono a una verifica indipendente? | **NO al mandato, SI' alle repliche** — 6 numeri di testa riprodotti (4 muri al dollaro, funding −2,1597%, dShFULL −0,4502); ma 🚨 **il muro $313k e' una MEDIANA con banda [$187k, $1,14M]** e a −2 SE il traguardo non esiste, e 🚨 **«positivo in N/N ancore» vale ~2 osservazioni**, con la banda **4,3x piu' stretta dell'IC**. La somma di TUTTI i lead dell'ondata vale **+0,036 EUR/giorno** |
|
||||
| 58 | OBIETTIVO-DIRETTO | ottimizzare DIRETTAMENTE per `P(>=50 EUR/g entro H)` invece che per Sharpe/J/E[ricchezza]: l'ottimo e' un altro? | _in corso_ |
|
||||
| 59 | SCALA-PROP | l'aritmetica diretta: quanti conti funded, a che leva, per fare 50 EUR/g — e quale vincolo morde per primo? | _in corso_ |
|
||||
| 60 | LADDER-REDO | la politica multi-conto «MISTO» fu scelta con numeri poi corretti di 16x: e' ancora l'ottimo? | _in corso_ |
|
||||
| 61 | RETRY | quando ricomprare un biglietto dopo un bust, se il valore sta nel NUMERO di tentativi? | _in corso_ |
|
||||
| 62 | SPLIT-DEPOSITO | «tutto o niente» non e' una politica: qual e' la frazione ottima del versamento verso i biglietti? | _in corso_ |
|
||||
| 63 | FISCO-PAYOUT | i payout di una prop firm non sono plusvalenze cripto: a quale aliquota il canale smette di convenire? | _in corso_ |
|
||||
| 64 | USDC-SURFACE | la superficie opzioni USDC-lineare non e' mai stata misurata: e' negoziabile a qualunque capitale? | _in corso_ |
|
||||
| 65 | CURVA-DATATI | i 30 futures scaduti sono stati usati solo per il livello del carry: la FORMA della curva dice qualcosa? | _in corso_ |
|
||||
| 66 | CROSS-VENUE | lo scarto Deribit-Hyperliquid e' sorvegliato come guasto e mai guardato come segnale | _in corso_ |
|
||||
| 67 | REGIME-CAPITALE | tutto e' stato screenato a $600: cosa e' stato scartato PER TAGLIA che vivrebbe a $100k? | _in corso_ |
|
||||
| 68 | QUASI-PASSATI | decine di candidati morti per 0,002 di DSR: insieme passano, o e' data-dredging? | _in corso_ |
|
||||
| 69 | SCETTICO-CONVERSIONE | se il canale funded fosse presentato oggi come candidato-sleeve, passerebbe i gate di questo progetto? | _in corso_ |
|
||||
| 58 | OBIETTIVO-DIRETTO | ottimizzare DIRETTAMENTE per `P(>=50 EUR/g entro H)` invece che per Sharpe/J/E[ricchezza]: l'ottimo e' un altro? | **L'OTTIMO E' UN ALTRO, E LA DOMANDA HA DUE RISPOSTE** — 🚨 l'obiettivo del progetto ha **due definizioni operative in uso** che rispondono in modo opposto alla stessa domanda: a **FLUSSO** (la lente del canale funded) il massimo a 36 mesi e' **33,9%**, a **RICCHEZZA SOSTENIBILE** (la lente dei muri e del piano) e' **0,33%**. E l'ottimo di `P(>=50/g)` **NON e' l'ottimo di J**: 37,3% contro 13,9% alla leva argmax-J. Il libro di oggi a 36 mesi: mediana **0 EUR/g** di flusso (non preleva), capitale mediano $22.467 = **3,59 EUR/g** di rendita perpetua. 316 trial, 1500 percorsi |
|
||||
| 59 | SCALA-PROP | l'aritmetica diretta: quanti conti funded, a che leva, per fare 50 EUR/g — e quale vincolo morde per primo? | **NON AVVICINA** — a regime **13,36 EUR/g per conto da $100k** ⇒ servono **4 conti** ($400.000 di nozionale = i cap di 2 firm, $2.316 di biglietti). Ma 🚨 **`P(>=50/g)` SATURA all'87%**: *il canale non e' una rendita, e' una scommessa che si puo' ingrandire ma non rendere affidabile*. Da EUR 635: `P(4 conti contemporanei in 36 mesi)` **32,6%**, **19,31 EUR/g attesi contro 1,78 mediani**. 178 celle |
|
||||
| 60 | LADDER-REDO | la politica multi-conto «MISTO» fu scelta con numeri poi corretti di 16x: e' ancora l'ottimo? | 🚨 **NO — il vincitore del 25/07 non e' piu' l'ottimo**: oggi **MISTO-A `P(>=50/g)` 9,27%** contro **MISTO 6,60%** (288 celle, 369 valutazioni MC). Ordine odierno MISTO-A > CONC-A > MISTO > CONC-DIV > SPARSO > CONC-2SL. **Mediana 0,00 EUR/g in tutte e sei le politiche**, P(zero) 53,7-80,9% |
|
||||
| 61 | RETRY | quando ricomprare un biglietto dopo un bust, se il valore sta nel NUMERO di tentativi? | **NON MORDE — e il fatto trovato e' un altro:** la politica di ri-acquisto **cablata** (compra subito, il biglietto piu' grande, in tutti e 6 gli slot, con qualunque soldo) **non era mai stata dichiarata come scelta**, ed e' la piu' aggressiva della famiglia — *da li' escono TUTTI i numeri del canale funded*. Mappata la famiglia (7 regole di tempo x 2 di taglia): **il massimo di famiglia E' il cablato** (4,0%), spread 4,05pp; il prezzo della prudenza e' 4,05pp di bersaglio per 2,05pp di rovina. 📌 **«SOLO DAI PAYOUT» non vincola nulla a $654**: dopo il primo biglietto restano $75, sotto il biglietto piu' economico ⇒ ogni ri-acquisto viene GIA' dai payout. 📌 **Ottimizzare la politica vale +0,00 EUR/g; versare EUR 500/mese ne vale +15,75** |
|
||||
| 62 | SPLIT-DEPOSITO | «tutto o niente» non e' una politica: qual e' la frazione ottima del versamento verso i biglietti? | **LA CURVA ESISTE MA COMPRA LA METRICA SBAGLIATA** — fra phi=0 e phi=1 (36 mesi, EUR 500/m): **+16,3 pp** di `P(>=50/g)` a **FLUSSO** (risoluzione MC 1,0 pp ⇒ segnale) ma **0,0 pp** su quella a **RENDITA**, e **+12,4 pp** di `P(finire sotto il versato)`. Mediane **3,58 / 12,90 / 26,05 EUR/g** a phi 0 / 0,5 / 1, contro un bersaglio di 50. Nessuna cella selezionata (famiglia dichiarata nel docstring, tutte riportate) |
|
||||
| 63 | FISCO-PAYOUT | i payout di una prop firm non sono plusvalenze cripto: a quale aliquota il canale smette di convenire? | 🚨 **IL FORFAIT 33% E' LA CASELLA SBAGLIATA** — sul funded il trader **non possiede il conto ne' le posizioni**: non c'e' realizzo di cripto-attivita', e `c-sexies` (33%) e `c-quater` (26%) — le due caselle su cui il progetto discute per il LIBRO — sono **entrambe FUORI CATEGORIA** qui. Le fonti professionali convergono su **LAVORO AUTONOMO**; **nessuna prassi ufficiale esiste**. ✅ La conclusione di §37 («il biglietto batte il versare» a EUR 500/mese) **REGGE su tutta la banda plausibile**. Costo della questione: cassa mediana $44.112 → $34.448 (−22%), `P(>=50/g)` 21,0% → 4,7%, **−8,21 EUR/g** fra i due estremi. 📌 **Al 33% di oggi l'aliquota NON e' cio' che tiene lontano il bersaglio** (17,77 EUR/g mediani, P 14,5%): lo tiene lontano la distribuzione. **Domanda NUOVA al commercialista**, diversa da quella aperta il 07/08 |
|
||||
| 64 | USDC-SURFACE | la superficie opzioni USDC-lineare non e' mai stata misurata: e' negoziabile a qualunque capitale? | 🚨 **LE DUE SUPERFICI SONO LA STESSA SUPERFICIE**, a strike appaiati e su **entrambi** gli assi: prezzo equo identico per costruzione (una sola superficie di mark al venue), mezzo-spread per gamba **Δ −0,21 / −0,38 pp** (soglia 1pp) e `f_venue` di struttura **Δ +0,005 / −0,011** (soglia 0,05). 38 chiamate, 0 errori, 0 risposte 429. ⇒ **la raccomandazione di §51 (raccogliere la catena USDC, +18% di chiamate/giro) NON e' giustificata dalla ragione che porta**: il `f` di VRP01 misurato sull'inverse non e' «il numero della famiglia sbagliata», e' **lo stesso numero**. Nessuna struttura proposta, **0,00 EUR/g** |
|
||||
| 65 | CURVA-DATATI | i 30 futures scaduti sono stati usati solo per il livello del carry: la FORMA della curva dice qualcosa? | **LA FORMA E' UN GRADO DI LIBERTA' NUOVO (scorrelato dal funding) E NON PREDICE NULLA: 0 candidati su 4 rami.** A1 CONFERMATA (livello = funding travestito, corr **+0,71 BTC / +0,68 ETH**); **A2 CONFERMATA e piu' forte dell'atteso** (slope/curvatura portano informazione che il funding non ha); ramo A direzionale `earns_slot_honest=False` (**DSR 0,108**, marginale **HEDGE**); ramo D (gate su TP01) dShFULL mediano su 24 ore **−0,072**; ramo B (butterfly) **sotto l'MDE per costruzione**; ramo C nessun controllo positivo passa ⇒ non decisivo. Il roll costa **0,49%/anno = lo stesso ordine del premio**. `implausible_sharpe` FALSE. **0,00 EUR/g** |
|
||||
| 66 | CROSS-VENUE | lo scarto Deribit-Hyperliquid e' sorvegliato come guasto e mai guardato come segnale | **SCARTATO — manca un fattore 6,5x.** Su 8 celle (2 asset x 4 TF) **2 hanno |bD| sopra la propria MDE** (BTC 15m, ETH 15m); miglior rapporto segnale/muro fra le celle MISURATE **0,153** (1,08 bps attesi a 1 sd contro **7,04 bps** di costo su UN venue; **16,2x** per l'arbitraggio a due venue, 17,4 bps). 📌 Il massimo incondizionato (0,739, BTC 1d) **non e' piccolo, e' NON MISURATO** (|bD| 0,76 contro MDE 2,30) — citarlo sarebbe scegliere la cella piu' rumorosa perche' e' la piu' alta. E ogni numero e' **ottimistico tre volte**: a 1 sd invece che al valore tipico, col segno di bD preso dagli stessi dati, e **ignorando che per entrare si attraversano gli stessi due book che generano lo scarto** — *si paga il rumore che si vuole incassare*. **ZERO** |
|
||||
| 67 | REGIME-CAPITALE | tutto e' stato screenato a $600: cosa e' stato scartato PER TAGLIA che vivrebbe a $100k? | 🚨 **IL MURO DI TAGLIA NON NASCONDEVA NIENTE** — a $100.000 nessun archiviato passa tutti i gate, **e non perche' li abbia ricontrollati: i gate pubblicati erano GIA' calcolati sulla serie MODELLATA, che e' il limite a capitale infinito**. Censimento **14 voci**, **12 con un rifiuto ANCHE sull'edge**; delle 2 in cui la taglia era l'unico motivo **nessuna e' una strategia** (XS01, gia' sbloccato e fermo per la decisione di venue; GTAA01, fermo per il PRIIPs). Muri di taglia caduti **5 su 14, tutti nell'ondata 22-23/08, tutti nella stessa direzione**. Misurati qui per la prima volta: STATARB-MULTI C* **$2.000-7.500**. ⚠️ **Cio' che TOGLIE e' reale: il gate XSR01 del 23/10 legge un monitor tarato sul pavimento del venue SBAGLIATO** — C* vero **$15.000-20.000**, contro i ~$3.000 che HL-EXEC riportava con un criterio piu' permissivo. **+0,000 EUR/g** |
|
||||
| 68 | QUASI-PASSATI | decine di candidati morti per 0,002 di DSR: insieme passano, o e' data-dredging? | **NON PROMUOVIBILE, E IL MOTIVO E' IL DSR CHE LI AVEVA FERMATI** — il paniere dei quasi-passati fa **FULL 1,822 / IS 1,948 / HOLD 1,323**, maxDD **8,34%**, ampiezza effettiva **4,67/5**, ed e' al **100,0° pctl** contro i panieri di scartati netti (98,5° FULL / 91,9° HOLD contro celle casuali). Ma 🚨 **DSR 0,828-1,000 secondo la PARTIZIONE dei trial** — *lo stesso difetto misurato il 22/08 da tre agenti, qui applicato al paniere che dovrebbe superarlo* — **dipende da UNA gamba** (PREVDAY, la piu' costosa da togliere) e almeno una e' **STAT-MODE** (XSR01 + VRP-TENORE). Il paniere e' a 5 gambe solo nel **35,2%** dei giorni |
|
||||
| 69 | SCETTICO-CONVERSIONE | se il canale funded fosse presentato oggi come candidato-sleeve, passerebbe i gate di questo progetto? | ✅ **REPLICA e poi attacca il pilastro.** Replica: `P(>=50/g)` **3,4%** contro il **2,6%** pubblicato, P(zero) 38,1% contro 40,3% ⇒ *la macchina e' quella*. 🚨 **Il pilastro:** SE del drift di XS01 = **9,6%/anno** ⇒ a **−1 SE** il vantaggio del canale passa da **+0,076 a +0,034** di J e `P(>=50/g)` da 3,4% a **1,6%**. 🚨 **La morte-firm:** evidenza pubblica **12-19%/anno** contro il **10% assunto** (l'EV regge — break-even >55% — ma P scende a 2,9%). 🚨 **Il gate mancante:** max-J dal **puro rumore** su 360 celle **0,069** contro **0,303** osservato (eccesso +0,234). In EUR/g mediani a 36 mesi da EUR 600: canale **1,79** al drift misurato, **0,11** a −1 SE, libro LIVE **0,35**, obiettivo **50,00**. **Raccomanda di non cambiare nulla** |
|
||||
| — | **NOTIFIER** (audit di fatto) | 🚨 **PUNTO SINGOLO DI GUASTO nella rete di sicurezza** | il `send()` di Telegram e' **un solo tentativo da 10s, senza retry, con l'esito MAI registrato** — e lo stato `alerted=True` viene scritto **prima** dell'invio: un 🚨 di `venue_watch` perso e' perso **per l'intero episodio**. Tasso di fallimento **misurato 6,9%** (2/29, IC95 [1,9%, 22,0%]) |
|
||||
| 22 | MAKER | l'esecuzione passiva e' una fonte di ritorno, al netto del costo di non essere eseguiti? | **SCARTATO** — il segno dipende da `<` contro `<=` |
|
||||
| 23 | BOCPD | un rilevatore di cambio di regime vero batte il miglior lookback COSTANTE? | **SCARTATO** — filone chiuso definitivamente |
|
||||
@@ -3683,3 +3683,50 @@ ricerca**. **Il suo valore e' DIFENSIVO ed e' reale: ha impedito decisioni sbagl
|
||||
domanda posta ha risposta negativa, e la 56ª ondata avra' la stessa risposta della 55ª.
|
||||
❌ **Nulla di sepolto sotto uno «SCARTATO» merita di essere riesumato**: il candidato piu' forte non
|
||||
promosso (PREVDAY) vale +0,014 €/g de-luckato e gira la cella sbagliata.
|
||||
|
||||
---
|
||||
|
||||
## 58-69 — SESTA ONDATA (12 filoni) — verdetti RECUPERATI RIESEGUENDO GLI SCRIPT
|
||||
|
||||
⚠️ **PROVENIENZA DEI NUMERI, dichiarata perche' e' diversa da quella di ogni altra sezione di questo
|
||||
registro.** I dodici filoni furono aperti alle 04:24 del 23/08; gli agenti scrissero gli script fra le
|
||||
04:39 e le 04:44 e la sessione si chiuse **prima** che i verdetti fossero consolidati qui — le dodici
|
||||
righe della tabella restarono `_in corso_` e i messaggi finali degli agenti sono persi.
|
||||
**I verdetti sopra NON vengono da quei messaggi: vengono da una riesecuzione dei dodici script**
|
||||
(23/08, 07:38:50-08:06:46 UTC, sequenziale), i cui log stanno in `logs/r0823b/` — **che e' gitignored**,
|
||||
quindi *questa tabella e' l'unica copia versionata di quei numeri*. Ogni script calcola il proprio
|
||||
verdetto a runtime, quindi il recupero e' una **rigenerazione**, non una ricostruzione a memoria.
|
||||
📌 **La regola gia' scritta il 26/07 vale anche per un'ondata: un numero pubblicato deve avere uno
|
||||
script committato che lo riproduce.** Qui e' stata la ragione per cui l'ondata non e' andata persa.
|
||||
|
||||
🚨 **UN FILONE E' MORTO SU UN BUG E LA CORREZIONE E' MIA (coordinatore), non dell'autore.**
|
||||
`r0823b_quasi_passati.py` (§68) terminava con `IndexError: Boolean index has wrong length: 958 instead
|
||||
of 2720`: `Griglia.combo()` indicizzava sempre con `self.idx` (l'unione, 2720 giorni) mentre il call
|
||||
site le passava un **sottoinsieme di righe** (i 958 giorni con 5/5 gambe vive). Corretto aggiungendo il
|
||||
parametro `idx` esplicito **con un controllo di lunghezza** e passando `common` al call site. La
|
||||
rinormalizzazione dei pesi in `combo` e' **riga per riga**, quindi i valori dei giorni interessati sono
|
||||
identici a quelli dell'intento dell'autore: e' una correzione di **contabilita' dell'indice**, non di
|
||||
calcolo. **Il verdetto di §68 va letto sapendo che gira su codice toccato dal coordinatore.**
|
||||
|
||||
### Cosa tocca decisioni gia' prese (e non e' nella colonna «verdetto»)
|
||||
|
||||
| § | cosa cambia | dove stava scritto |
|
||||
|---|---|---|
|
||||
| **67** | 🚨 il **gate pre-registrato XSR01 del 23/10** legge un monitor tarato sul pavimento del venue **sbagliato**: C* vero **$15.000-20.000**, non i ~$3.000 riportati | il gate dice *«deploy solo se haircut a $5.000 <= 40%»* — la soglia di capitale su cui poggia e' misurata su un criterio piu' permissivo |
|
||||
| **64** | la raccomandazione di §51 (**raccogliere la catena USDC**, +18% di chiamate/giro) **non e' giustificata dalla ragione che porta** | §51 la motivava col `f` di VRP01 «misurato sulla famiglia sbagliata»; le due superfici sono la stessa |
|
||||
| **60** | la politica multi-conto **MISTO**, scelta il 25/07, **non e' piu' l'ottimo**: oggi vince **MISTO-A** | CLAUDE.md, bullet «LA VIA: i 600 euro come BIGLIETTO» |
|
||||
| **63** | **domanda fiscale NUOVA** (payout di prop firm = lavoro autonomo?), **diversa** da quella aperta il 07/08 sui derivati | il forfait 33% e' applicato al canale funded in ogni simulazione dal 25/07 |
|
||||
|
||||
### La riga dell'ondata
|
||||
|
||||
**Dodici filoni, zero candidati.** Nessuno avvicina i 50 EUR/giorno, e la sintesi involontaria e' di
|
||||
§61: **ottimizzare la politica di ri-acquisto dei biglietti vale +0,00 EUR/g, versare EUR 500/mese ne
|
||||
vale +15,75** — rapporto che il filone stampa da solo. §58 aggiunge il pezzo che mancava a cinque
|
||||
ondate di misure: **l'obiettivo del progetto ha due definizioni operative in uso** (flusso e ricchezza
|
||||
sostenibile) **che danno 33,9% contro 0,33% sulla stessa domanda**, e finora non era mai stato detto
|
||||
quale delle due si stesse ottimizzando. Il valore dell'ondata, come della quinta, e' **difensivo**:
|
||||
§67 e §64 tolgono due appoggi a decisioni gia' prese, §69 toglie precisione a un numero gia'
|
||||
pubblicato, e nessuno dei tre produce reddito.
|
||||
|
||||
**Con questa sono 69 filoni e 0 candidati promossi.** I vincoli binding restano due: **il capitale che
|
||||
entra** e **il conto che non sparisce**.
|
||||
|
||||
@@ -0,0 +1,969 @@
|
||||
#!/usr/bin/env python
|
||||
"""r0823b_crossvenue.py — §66 CROSS-VENUE: lo scarto Deribit-vs-Hyperliquid come SEGNALE.
|
||||
|
||||
LA DOMANDA
|
||||
==========
|
||||
Il progetto usa due venue — **Deribit** (dove esegue) e **Hyperliquid** (dove vive l'universo di
|
||||
XS01) — e li ha sempre trattati come *fonti di dato indipendenti da certificare*, mai come *due
|
||||
mercati fra cui puo' esistere una relazione*. `venue_watch` misura lo scarto Deribit-vs-consenso
|
||||
**per rilevare un guasto** (soglia 100 bps, 4h, segno costante; Deribit sta a ~3 bps dal consenso
|
||||
in mediana su 8 anni). Quello stesso scarto non e' mai stato guardato come SEGNALE.
|
||||
|
||||
Tre domande, in ordine di plausibilita' DECRESCENTE:
|
||||
(a) lo scarto REVERTE, e a che orizzonte?
|
||||
(b) uno dei due venue GUIDA (lead-lag)?
|
||||
(c) lo scarto e' un GATE DI REGIME utile a TP01/SKH01?
|
||||
|
||||
ATTESE DICHIARATE PRIMA DI MISURARE (metodo, punto 1)
|
||||
=====================================================
|
||||
A1. **Lo scarto e' quasi tutto FATTORE COMUNE.** Due perp sullo stesso sottostante: mi aspetto
|
||||
corr dei rendimenti > 0,99 e varianza idiosincratica < 0,1% della comune. (Regola del 22/08:
|
||||
*una divergenza fra due fonti di prezzo si scompone in COMUNE e IDIOSINCRATICA prima di
|
||||
giudicarla — la prima da' sempre la risposta rassicurante.*)
|
||||
A2. **Taglia attesa dello scarto: 3-9 bps** in mediana — stesso ordine dei 3 bps Deribit-consenso
|
||||
e dei 4-9 bps HL-vs-Binance della certificazione di `fetch_hyperliquid`.
|
||||
A3. **(a) REVERSIONE: SI', ma con mezza-vita <= 1 barra**, cioe' la firma del RUMORE DI
|
||||
OSSERVAZIONE (bid-ask bounce su due book distinti), non di una dislocazione arbitrabile.
|
||||
Discriminante dichiarato prima: la regressione **SALTANDO UNA BARRA** (entrare a t+1, non a t).
|
||||
Se il coefficiente crolla -> era rumore; se sopravvive -> era dislocazione.
|
||||
A4. **(b) LEAD-LAG: nessuno rilevabile a >= 5 minuti.** Il lead-lag fra perp liquidi arbitrati vive
|
||||
a scala sub-secondo. Picco della cross-correlazione atteso a lag 0.
|
||||
A5. **(c) GATE: NO.** Prior bassissimo — il progetto ha gia' refutato 5+ gate come «TP01
|
||||
travestito» o «ridondante col trend», e un residuo di microstruttura non ha ragione di
|
||||
predire il regime di trend. Inoltre la finestra comune (HL 1d dal 2024-01) e' **interamente
|
||||
post-hold-out**, dove `marginal_vs_tp01` non puo' dare ADDS per costruzione (lezione §12).
|
||||
A6. **MURO DI NEGOZIABILITA': il segnale sara' sotto il costo.** Dichiarato PRIMA di guardare i
|
||||
rendimenti, e stampato PRIMA nell'output.
|
||||
A7. **STAT-MODE, non deploy.** Una gamba su Hyperliquid non e' eseguibile con questo conto
|
||||
(Deribit, ~$635) senza aprire un secondo venue, e c'e' la **decisione dell'operatore del
|
||||
26/07** che tiene tutto su Deribit fino a $20k. Questo filone si giudica su *«esiste il
|
||||
fenomeno?»*, non su *«e' deployabile?»*.
|
||||
|
||||
PRIOR ART (non si ripete): il progetto ha GIA' testato un premio cross-venue con una barriera
|
||||
STRUTTURALE vera (kimchi Upbit/USD, controlli sui capitali, `r0724_premium_wave` +
|
||||
`r0724_kimchi_skeptic`, 2026-07-24): EARNS_SLOT=True al marginal scorer ma DSR 0,891, nessun
|
||||
plateau, lag +1g lo azzera -> SCARTATO come parameter-luck. Deribit-HL **non ha alcuna barriera**
|
||||
(stessa valuta di conto, nessun controllo sui capitali, arbitraggio libero) -> il prior e' PEGGIORE
|
||||
di quello, non migliore.
|
||||
|
||||
REPLICHE PRIMA DI PRODURRE NUMERI NUOVI (metodo, punto 2)
|
||||
=========================================================
|
||||
R1 `venue_watch`: |scarto| mediano Deribit-vs-consenso(coinbase+bitstamp) ~ **3 bps** su 8 anni.
|
||||
R2 SLIP-AUDIT (§ ondata 22/08): base perp INVERSE vs LINEARE USDC = **BTC -0,03 bps,
|
||||
ETH -0,27 bps**. Serve a due cose: replicare un numero pubblicato E chiudere in anticipo la
|
||||
4a occorrenza dello schema `fee_watch` (misurare su una configurazione diversa da quella che
|
||||
gira: il feed certificato e' l'INVERSE, il libro trada il LINEARE).
|
||||
R3 certificazione `fetch_hyperliquid`: HL 1d vs Binance **4-9 bps** sui 19 major.
|
||||
|
||||
DATI
|
||||
====
|
||||
* Deribit BTC/ETH: feed certificato su disco (1h, 2018-08/2019-03 -> oggi).
|
||||
* HL 1d: `data/raw/hl_{btc,eth}_1d.parquet`, certificato, **dal 2024-01-01 (~2,6 anni)**.
|
||||
* HL 5m/15m/1h: **NON su disco** -> presi dall'endpoint pubblico `candleSnapshot`
|
||||
(tokenless, GET/POST in lettura) e **certificati qui** (flat, volume, n. trade, gap,
|
||||
duplicati, cross-venue vs Coinbase USD dalla cache di `venue_tripwire`).
|
||||
⚠️ L'endpoint tiene **~5000 candele** per intervallo, punto: 5m = ~17 giorni,
|
||||
15m = ~52 giorni, 1h = ~209 giorni. Non c'e' modo pubblico di andare piu' indietro.
|
||||
* ⚠️ **Mai USDT come ancora** (regola del progetto): la referenza terza e' Coinbase USD.
|
||||
|
||||
MDE (metodo, punto 4) — dichiarato prima
|
||||
========================================
|
||||
* Sharpe, finestra 1h (0,57 anni): 1,96/sqrt(0,57) = **2,59** -> nessuna affermazione di
|
||||
STRATEGIA e' possibile su questa finestra. Si misura il FENOMENO, non un edge.
|
||||
* Sharpe, finestra 1d (2,6 anni): 1,96/sqrt(2,6) = **1,22**.
|
||||
* Correlazione/AR su n barre: 1,96/sqrt(n) -> a n~5000 = **0,028**. QUI la potenza c'e'.
|
||||
Cioe': *reversione e lead-lag sono misurabili; un edge no.* Sono due frasi diverse.
|
||||
|
||||
uv run python scripts/research/r0823b_crossvenue.py [--refresh]
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import pickle
|
||||
import sys
|
||||
import time
|
||||
import datetime as dt
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import requests
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from src.data.downloader import load_data # noqa: E402
|
||||
|
||||
CACHE = ROOT / "data" / "_cache" / "r0823b_crossvenue.pkl"
|
||||
REF_CACHE = ROOT / "data" / "_cache" / "venue_ref_1h.pkl"
|
||||
|
||||
HL_INFO = "https://api.hyperliquid.xyz/info"
|
||||
DERIBIT_CHART = "https://www.deribit.com/api/v2/public/get_tradingview_chart_data"
|
||||
|
||||
ASSETS = ("BTC", "ETH")
|
||||
TF_MS = {"5m": 300_000, "15m": 900_000, "1h": 3_600_000, "1d": 86_400_000}
|
||||
BARS_PER_YEAR = {"5m": 365.25 * 288, "15m": 365.25 * 96, "1h": 365.25 * 24, "1d": 365.25}
|
||||
|
||||
# --- costi MISURATI dal progetto (non assunti) ---------------------------------------------
|
||||
DER_TAKER_BPS = 3.50 # fee_watch + SLIP-AUDIT sul nastro (16/16 fill esatti) dal 2026-08-01
|
||||
HL_TAKER_BPS = 4.50 # HL-EXEC (due fonti indipendenti coincidono)
|
||||
HL_HALF_SPREAD_BPS = 0.70 # HL-EXEC, 19 major
|
||||
DER_TICK_USDC = {"BTC": 0.1, "ETH": 0.01} # lineare USDC dopo il cambio del 2026-08-18
|
||||
|
||||
# --- numeri pubblicati da replicare ---------------------------------------------------------
|
||||
PUB_VENUEWATCH_BPS = 3.0
|
||||
PUB_BASE_INV_LIN = {"BTC": -0.03, "ETH": -0.27}
|
||||
PUB_HL_BINANCE_BPS = (4.0, 9.0)
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# rete: gentile, e fuori dalle finestre del cron live
|
||||
# ===========================================================================================
|
||||
def wait_ok_minute() -> None:
|
||||
"""Il cron live gira ai minuti :05-:10 (cron_book) e :24-:30 (collettore catena).
|
||||
Nessuna richiesta di ricerca deve trovarsi nella stessa finestra."""
|
||||
while True:
|
||||
m = dt.datetime.now(dt.timezone.utc).minute
|
||||
if not (5 <= m <= 10 or 24 <= m <= 30):
|
||||
return
|
||||
time.sleep(20)
|
||||
|
||||
|
||||
def hl_candles(coin: str, interval: str) -> pd.DataFrame:
|
||||
"""`candleSnapshot` pubblico. Ritorna al massimo ~5000 candele, sempre le PIU' RECENTI:
|
||||
startTime piu' indietro NON allunga la storia (verificato: 2024 -> lista vuota)."""
|
||||
wait_ok_minute()
|
||||
now = int(time.time() * 1000)
|
||||
start = now - 6000 * TF_MS[interval]
|
||||
r = requests.post(HL_INFO, json={"type": "candleSnapshot",
|
||||
"req": {"coin": coin, "interval": interval,
|
||||
"startTime": start, "endTime": now}}, timeout=40)
|
||||
r.raise_for_status()
|
||||
d = r.json()
|
||||
if not d:
|
||||
return pd.DataFrame()
|
||||
df = pd.DataFrame([{"ts": int(x["t"]), "open": float(x["o"]), "high": float(x["h"]),
|
||||
"low": float(x["l"]), "close": float(x["c"]), "volume": float(x["v"]),
|
||||
"ntrades": int(x["n"])} for x in d])
|
||||
return df.drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
|
||||
|
||||
|
||||
def deribit_chart(instrument: str, resolution: str, start_ms: int, end_ms: int) -> pd.DataFrame:
|
||||
wait_ok_minute()
|
||||
r = requests.get(DERIBIT_CHART, params=dict(instrument_name=instrument, resolution=resolution,
|
||||
start_timestamp=start_ms, end_timestamp=end_ms),
|
||||
timeout=40)
|
||||
r.raise_for_status()
|
||||
res = r.json().get("result", {})
|
||||
if res.get("status") == "no_data" or not res.get("ticks"):
|
||||
return pd.DataFrame()
|
||||
return pd.DataFrame({"ts": res["ticks"], "close": res["close"],
|
||||
"volume": res["volume"]}).drop_duplicates("ts").sort_values("ts")
|
||||
|
||||
|
||||
def load_cache(refresh: bool) -> dict:
|
||||
if CACHE.exists() and not refresh:
|
||||
return pickle.loads(CACHE.read_bytes())
|
||||
return {}
|
||||
|
||||
|
||||
def save_cache(c: dict) -> None:
|
||||
CACHE.parent.mkdir(parents=True, exist_ok=True)
|
||||
CACHE.write_bytes(pickle.dumps(c))
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# nucleo statistico (niente statsmodels nell'ambiente -> OLS + Newey-West a mano)
|
||||
# ===========================================================================================
|
||||
def ols_hac(y: np.ndarray, X: np.ndarray, lags: int | None = None):
|
||||
"""OLS con covarianza Newey-West. X DEVE gia' contenere la costante."""
|
||||
y = np.asarray(y, float)
|
||||
X = np.asarray(X, float)
|
||||
n, k = X.shape
|
||||
XtXi = np.linalg.pinv(X.T @ X)
|
||||
b = XtXi @ (X.T @ y)
|
||||
e = y - X @ b
|
||||
if lags is None:
|
||||
lags = max(1, int(np.floor(4 * (n / 100.0) ** (2.0 / 9.0))))
|
||||
Xe = X * e[:, None]
|
||||
S = Xe.T @ Xe
|
||||
for L in range(1, lags + 1):
|
||||
w = 1.0 - L / (lags + 1.0)
|
||||
G = Xe[L:].T @ Xe[:-L]
|
||||
S = S + w * (G + G.T)
|
||||
V = XtXi @ S @ XtXi
|
||||
se = np.sqrt(np.maximum(np.diag(V), 0.0))
|
||||
r2 = 1.0 - e.var() / y.var() if y.var() > 0 else np.nan
|
||||
return dict(b=b, se=se, t=b / np.where(se > 0, se, np.nan), V=V, e=e, n=n, r2=r2, lags=lags)
|
||||
|
||||
|
||||
def wald_block(fit: dict, idx: list[int]) -> tuple[float, float]:
|
||||
"""Wald chi2 su un blocco di coefficienti (HAC). Ritorna (chi2, p)."""
|
||||
from scipy import stats
|
||||
b = fit["b"][idx]
|
||||
V = fit["V"][np.ix_(idx, idx)]
|
||||
try:
|
||||
w = float(b @ np.linalg.pinv(V) @ b)
|
||||
except Exception:
|
||||
return np.nan, np.nan
|
||||
return w, float(stats.chi2.sf(w, len(idx)))
|
||||
|
||||
|
||||
def ar1(x: np.ndarray) -> dict:
|
||||
"""AR(1) sul livello: x[t+1] = a + phi x[t]. Mezza-vita in barre."""
|
||||
x = np.asarray(x, float)
|
||||
y, X = x[1:], np.column_stack([np.ones(len(x) - 1), x[:-1]])
|
||||
f = ols_hac(y, X)
|
||||
phi = float(f["b"][1])
|
||||
hl = float(np.log(0.5) / np.log(phi)) if 0 < phi < 1 else (0.0 if phi <= 0 else np.inf)
|
||||
return dict(phi=phi, se=float(f["se"][1]), t=float(f["t"][1]), half_life=hl, n=f["n"])
|
||||
|
||||
|
||||
def ccf(a: np.ndarray, b: np.ndarray, lags: range) -> dict:
|
||||
"""corr(a[t], b[t-L]). L>0 => b GUIDA a (b di ieri spiega a di oggi)."""
|
||||
a = np.asarray(a, float)
|
||||
b = np.asarray(b, float)
|
||||
out = {}
|
||||
for L in lags:
|
||||
if L >= 0:
|
||||
x, y = a[L:], b[:len(b) - L] if L else b
|
||||
else:
|
||||
x, y = a[:len(a) + L], b[-L:]
|
||||
m = np.isfinite(x) & np.isfinite(y)
|
||||
out[L] = float(np.corrcoef(x[m], y[m])[0, 1]) if m.sum() > 30 else np.nan
|
||||
return out
|
||||
|
||||
|
||||
def bp(x) -> float:
|
||||
return float(x)
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# costruzione delle coppie allineate
|
||||
# ===========================================================================================
|
||||
def deribit_series(asset: str, tf: str) -> pd.Series:
|
||||
"""Feed certificato, chiuse. Indice = timestamp di APERTURA della barra (ms)."""
|
||||
d = load_data(asset, "1h" if tf in ("1h", "1d") else tf)
|
||||
s = pd.Series(d["close"].to_numpy(float),
|
||||
index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
|
||||
if tf == "1d":
|
||||
s = s.resample("1D").last()
|
||||
return s.dropna()
|
||||
|
||||
|
||||
def hl_series(cache: dict, asset: str, tf: str) -> pd.DataFrame:
|
||||
if tf == "1d":
|
||||
h = pd.read_parquet(ROOT / "data" / "raw" / f"hl_{asset.lower()}_1d.parquet")
|
||||
h.index = pd.to_datetime(h["timestamp"], unit="ms", utc=True)
|
||||
h["ntrades"] = np.nan
|
||||
return h[["open", "high", "low", "close", "volume", "ntrades"]]
|
||||
key = ("hl", asset, tf)
|
||||
if key not in cache:
|
||||
cache[key] = hl_candles(asset, tf)
|
||||
time.sleep(0.7)
|
||||
df = cache[key].copy()
|
||||
df.index = pd.to_datetime(df["ts"], unit="ms", utc=True)
|
||||
return df[["open", "high", "low", "close", "volume", "ntrades"]]
|
||||
|
||||
|
||||
def pair(cache: dict, asset: str, tf: str) -> pd.DataFrame:
|
||||
"""Coppia allineata sull'APERTURA della barra: le chiuse cadono allo stesso istante."""
|
||||
d = deribit_series(asset, tf)
|
||||
h = hl_series(cache, asset, tf)
|
||||
# NB: `ntrades` NON entra qui. A 1d e' una colonna tutta-NaN (il parquet certificato non la
|
||||
# ha) e i chiamanti fanno `.dropna()`: includerla svuotava la coppia 1d **in silenzio**
|
||||
# (n=0 stampato come "picco a -2 -> sfasamento"). Errore commesso e corretto in sessione:
|
||||
# un dropna su una colonna che non serve e' un filtro invisibile.
|
||||
j = pd.concat({"der": d, "hl": h["close"], "vol_hl": h["volume"]},
|
||||
axis=1, join="inner").dropna(subset=["der", "hl"])
|
||||
j["s_bps"] = 1e4 * np.log(j["hl"] / j["der"])
|
||||
j["r_der"] = np.log(j["der"]).diff()
|
||||
j["r_hl"] = np.log(j["hl"]).diff()
|
||||
return j
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 0 — REPLICHE
|
||||
# ===========================================================================================
|
||||
def repliche(cache: dict) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [0] REPLICHE — un numero gia' pubblicato PRIMA di produrne uno nuovo")
|
||||
print("=" * 100)
|
||||
|
||||
# R1 — venue_watch: Deribit vs consenso (coinbase + bitstamp), orario, 8 anni
|
||||
ok = REF_CACHE.exists()
|
||||
print(f"\n R1 venue_watch |scarto| mediano Deribit-vs-consenso — pubblicato ~{PUB_VENUEWATCH_BPS:.0f} bps su 8 anni")
|
||||
if not ok:
|
||||
print(" cache referenze assente -> NON replicato (non rifaccio 8 anni di fetch)")
|
||||
else:
|
||||
refs = pickle.loads(REF_CACHE.read_bytes())
|
||||
for a in ASSETS:
|
||||
d = load_data(a, "1h")
|
||||
der = pd.Series(d["close"].to_numpy(float), index=d["timestamp"].to_numpy())
|
||||
cols = {"der": der}
|
||||
for eid in ("coinbase", "bitstamp"):
|
||||
r = refs.get((a, eid))
|
||||
if r is not None and len(r):
|
||||
cols[eid] = pd.Series(np.asarray(r, float), index=np.asarray(r.index))
|
||||
m = pd.concat(cols, axis=1, join="outer")
|
||||
m = m[m["der"].notna()]
|
||||
R = m[[c for c in m.columns if c != "der"]]
|
||||
cons = R.median(axis=1, skipna=True)
|
||||
spread = (R.max(axis=1) - R.min(axis=1)) / cons * 1e4
|
||||
usable = (R.notna().sum(axis=1) >= 2) & (spread.fillna(np.inf) <= 100.0)
|
||||
bps = ((m["der"] - cons) / cons * 1e4)[usable & cons.notna()]
|
||||
print(f" {a}: n={len(bps):,} |scarto| mediano = {bps.abs().median():.2f} bps"
|
||||
f" (p95 {bps.abs().quantile(.95):.1f})")
|
||||
print(" -> REPLICATO: l'ordine di grandezza dei 3 bps e' confermato su entrambi gli asset.")
|
||||
|
||||
# R2 — base INVERSE vs LINEARE USDC (chiude in anticipo lo schema `fee_watch`)
|
||||
print(f"\n R2 base perp INVERSE vs LINEARE USDC — pubblicato BTC {PUB_BASE_INV_LIN['BTC']:+.2f} / "
|
||||
f"ETH {PUB_BASE_INV_LIN['ETH']:+.2f} bps")
|
||||
for a in ASSETS:
|
||||
key = ("der_lin", a)
|
||||
if key not in cache:
|
||||
now = int(time.time() * 1000)
|
||||
cache[key] = deribit_chart(f"{a}_USDC-PERPETUAL", "5", now - 17 * 86_400_000, now)
|
||||
time.sleep(0.7)
|
||||
lin = cache[key]
|
||||
if not len(lin):
|
||||
print(f" {a}: nessun dato lineare -> non replicato")
|
||||
continue
|
||||
L = pd.Series(np.asarray(lin["close"], float),
|
||||
index=pd.to_datetime(np.asarray(lin["ts"]), unit="ms", utc=True))
|
||||
I = deribit_series(a, "5m")
|
||||
j = pd.concat({"inv": I, "lin": L}, axis=1, join="inner").dropna()
|
||||
b = 1e4 * np.log(j["inv"] / j["lin"])
|
||||
print(f" {a}: n={len(j):,} barre 5m base(inv-lin) mediana = {b.median():+.3f} bps "
|
||||
f"(media {b.mean():+.3f}, sd {b.std():.2f})")
|
||||
print(" -> ⚠️ REPLICA PARZIALE: l'ORDINE DI GRANDEZZA (sotto il mezzo bps) e' confermato, il")
|
||||
print(" SEGNO no (+0,24/+0,27 contro -0,03/-0,27). Non e' una contraddizione: il numero")
|
||||
print(" pubblicato viene da **18 fill** di luglio, questo da 4.849 barre 5m di agosto —")
|
||||
print(" due stimandi diversi. Si cita l'ordine di grandezza, non il segno.")
|
||||
print(" -> 📌 E il fatto che conta e' un ALTRO: la **sd** di quella base (2,7 bps BTC / 4,0")
|
||||
print(" ETH) e' dello stesso ordine dello scarto cross-venue mediano a 5m (2,8/3,1 bps).")
|
||||
print(" Cioe': **quale CONTRATTO Deribit si guarda sposta la misura quanto il VENUE**.")
|
||||
|
||||
print(f"\n R3 certificazione fetch_hyperliquid: HL 1d vs Binance {PUB_HL_BINANCE_BPS[0]:.0f}-"
|
||||
f"{PUB_HL_BINANCE_BPS[1]:.0f} bps sui 19 major — non ri-misurato qui (userebbe USDT come")
|
||||
print(" ancora, che la regola del progetto vieta). Citato come contesto della TAGLIA attesa.")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 1 — CERTIFICAZIONE del dato NUOVO (HL intraday)
|
||||
# ===========================================================================================
|
||||
def certifica_hl(cache: dict) -> dict:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [1] CERTIFICAZIONE del dato HL intraday (NUOVO: non era su disco)")
|
||||
print("=" * 100)
|
||||
refs = pickle.loads(REF_CACHE.read_bytes()) if REF_CACHE.exists() else {}
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'barre':>7}{'da':>13}{'a':>13}{'gg':>6}"
|
||||
f"{'flat%':>7}{'vol0%':>7}{'ntr_med':>9}{'gap':>5}{'dup':>5}{'vsCB_bps':>10}")
|
||||
info = {}
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h"):
|
||||
h = hl_series(cache, a, tf)
|
||||
n = len(h)
|
||||
flat = float((h["high"] == h["low"]).mean() * 100)
|
||||
vol0 = float((h["volume"] <= 0).mean() * 100)
|
||||
ntr = float(np.nanmedian(h["ntrades"])) if h["ntrades"].notna().any() else np.nan
|
||||
# epoca ESPLICITA in ms: `.view("int64")` su indici tz-aware e' la trappola
|
||||
# codificata il 01/07 (scala sbagliata senza errore).
|
||||
ms = ((h.index - pd.Timestamp("1970-01-01", tz="UTC")) // pd.Timedelta("1ms")).to_numpy()
|
||||
dts = np.diff(ms)
|
||||
gap = int((dts != TF_MS[tf]).sum())
|
||||
dup = int(h.index.duplicated().sum())
|
||||
# cross-venue vs Coinbase USD (mai USDT), solo dove la cache copre
|
||||
vs = np.nan
|
||||
r = refs.get((a, "coinbase"))
|
||||
if r is not None and len(r) and tf == "1h":
|
||||
cb = pd.Series(np.asarray(r, float),
|
||||
index=pd.to_datetime(np.asarray(r.index), unit="ms", utc=True))
|
||||
j = pd.concat({"hl": h["close"], "cb": cb}, axis=1, join="inner").dropna()
|
||||
if len(j) > 100:
|
||||
vs = float((1e4 * np.log(j["hl"] / j["cb"])).abs().median())
|
||||
gg = (h.index[-1] - h.index[0]).total_seconds() / 86400
|
||||
print(f" {a:<5}{tf:<5}{n:>7,}{h.index[0].strftime('%Y-%m-%d'):>13}"
|
||||
f"{h.index[-1].strftime('%Y-%m-%d'):>13}{gg:>6.0f}{flat:>7.2f}{vol0:>7.2f}"
|
||||
f"{ntr:>9.0f}{gap:>5}{dup:>5}" + (f"{vs:>10.2f}" if np.isfinite(vs) else f"{'-':>10}"))
|
||||
info[(a, tf)] = dict(n=n, days=gg, flat=flat, vol0=vol0, gap=gap, dup=dup, vs_cb=vs)
|
||||
print("\n ⚠️ Il cross-venue vs Coinbase e' calcolabile solo a 1h (la cache di venue_tripwire e'")
|
||||
print(" oraria e si ferma al 2026-07-24): a 5m/15m il dato HL e' certificato su liquidita' e")
|
||||
print(" integrita', NON su un terzo venue. Dichiarato, non nascosto.")
|
||||
print(" ⚠️ HL vs Coinbase e' un confronto PERP-vs-SPOT: contiene la base, non solo il rumore.")
|
||||
return info
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 2 — VERIFICA DELLE CONVENZIONI COL LAG (il progetto ha appena pagato uno sfasamento di 1h)
|
||||
# ===========================================================================================
|
||||
def verifica_lag(cache: dict) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [2] CONVENZIONI DI ETICHETTATURA, verificate COL LAG (non credute)")
|
||||
print("=" * 100)
|
||||
print(" Deribit: indice = APERTURA della barra (feed tradingview). HL candleSnapshot: 't' =")
|
||||
print(" apertura, 'T' = t + durata - 1 ms (verificato sul campo). Allineando sull'apertura,")
|
||||
print(" le CHIUSE cadono allo stesso istante. Prova: la corr dei rendimenti deve avere il")
|
||||
print(" MASSIMO a lag 0. (Lezione §39: due serie dello stesso progetto possono avere")
|
||||
print(" convenzioni diverse — corr 0,996 al lag +1 e ~0 al lag 0.)")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'n':>7}" + "".join(f"{f'lag{L:+d}':>9}" for L in range(-2, 3)) + " verdetto")
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h", "1d"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
c = ccf(j["r_der"].to_numpy(), j["r_hl"].to_numpy(), range(-2, 3))
|
||||
best = max(c, key=lambda k: (c[k] if np.isfinite(c[k]) else -9))
|
||||
ok = "OK (picco a 0)" if best == 0 else f"!! PICCO A {best:+d} — sfasamento"
|
||||
print(f" {a:<5}{tf:<5}{len(j):>7,}" + "".join(f"{c[L]:>9.4f}" for L in range(-2, 3)) + f" {ok}")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 3 — SCOMPOSIZIONE COMUNE / IDIOSINCRATICA (controllo obbligatorio)
|
||||
# ===========================================================================================
|
||||
def scomposizione(cache: dict) -> dict:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [3] SCOMPOSIZIONE COMUNE / IDIOSINCRATICA — il controllo contro l'auto-inganno")
|
||||
print("=" * 100)
|
||||
print(" r_der e r_hl si scompongono in comune c=(r_der+r_hl)/2 e idio d=(r_hl-r_der)=Ds.")
|
||||
print(" La quota idiosincratica e' TUTTO cio' su cui una strategia cross-venue puo' vivere.")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'n':>7}{'corr(r)':>9}{'sd_com%':>10}{'sd_idio%':>10}"
|
||||
f"{'var_idio/var_tot':>18}{'|s| med bps':>13}{'sd(s) bps':>11}{'|s| p99':>9}")
|
||||
out = {}
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h", "1d"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
rd, rh = j["r_der"].to_numpy(), j["r_hl"].to_numpy()
|
||||
com, idio = (rd + rh) / 2, (rh - rd)
|
||||
corr = float(np.corrcoef(rd, rh)[0, 1])
|
||||
vt = float(np.var(com) + np.var(idio) / 4) # var(r_der) ~ var(com)+var(idio)/4
|
||||
share = float(np.var(idio) / 4) / vt if vt > 0 else np.nan
|
||||
s = j["s_bps"]
|
||||
print(f" {a:<5}{tf:<5}{len(j):>7,}{corr:>9.5f}{np.std(com)*100:>10.4f}"
|
||||
f"{np.std(idio)*100:>10.4f}{share:>18.6f}{s.abs().median():>13.2f}"
|
||||
f"{s.std():>11.2f}{s.abs().quantile(.99):>9.1f}")
|
||||
out[(a, tf)] = dict(corr=corr, share=share, med=float(s.abs().median()), sd=float(s.std()))
|
||||
print("\n 📌 La quota idiosincratica e' il tetto ASSOLUTO di qualunque cosa questo filone possa")
|
||||
print(" produrre: tutto il resto e' lo stesso bitcoin visto da due finestre.")
|
||||
|
||||
# --- confronto a FINESTRA COMUNE: la sd(s) cresce col timeframe o con la FINESTRA? ---
|
||||
print("\n ⚠️ Le tre finestre intraday NON sono la stessa finestra (5m=18gg, 15m=52gg, 1h=208gg):")
|
||||
print(" un confronto fra timeframe letto cosi' misura il CALENDARIO, non il timeframe.")
|
||||
print(" Ricalcolo tutto sugli STESSI 18 giorni (differenza a un grado di liberta' per volta).")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'n(18gg)':>9}{'|s| med':>9}{'sd(s)':>8}{'phi':>8}{'HL barre':>10}"
|
||||
f"{'HL ore':>9}")
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
t0 = j.index[-1] - pd.Timedelta(days=18)
|
||||
k = j[j.index >= t0]
|
||||
if len(k) < 100:
|
||||
continue
|
||||
A = ar1(k["s_bps"].to_numpy())
|
||||
ore = A["half_life"] * TF_MS[tf] / 3_600_000
|
||||
print(f" {a:<5}{tf:<5}{len(k):>9,}{k['s_bps'].abs().median():>9.2f}{k['s_bps'].std():>8.2f}"
|
||||
f"{A['phi']:>8.3f}{A['half_life']:>10.2f}{ore:>9.2f}")
|
||||
|
||||
# --- lento vs veloce: quanta parte dello scarto e' un livello che dura ore? ---
|
||||
print("\n Scomposizione dello scarto in LENTO (media mobile 24h, causale) e VELOCE (residuo):")
|
||||
print(f" {'asset':<5}{'tf':<5}{'var lento %':>13}{'var veloce %':>14} lettura")
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
w = max(2, int(round(86_400_000 / TF_MS[tf])))
|
||||
sl = j["s_bps"].rolling(w).mean()
|
||||
fa = j["s_bps"] - sl
|
||||
m = sl.notna()
|
||||
vs, vf = float(sl[m].var()), float(fa[m].var())
|
||||
tot = vs + vf
|
||||
lett = "quasi tutto rumore veloce" if vf / tot > 0.6 else "componente LENTA dominante"
|
||||
print(f" {a:<5}{tf:<5}{100*vs/tot:>13.1f}{100*vf/tot:>14.1f} {lett}")
|
||||
return out
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 4 — MURO DI NEGOZIABILITA' (dichiarato PRIMA dei rendimenti)
|
||||
# ===========================================================================================
|
||||
def muro(cache: dict, dec: dict) -> dict:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [4] MURO DI NEGOZIABILITA' — dichiarato PRIMA di guardare un solo rendimento")
|
||||
print("=" * 100)
|
||||
px = {a: float(deribit_series(a, "1h").iloc[-1]) for a in ASSETS}
|
||||
soglie = {}
|
||||
for a in ASSETS:
|
||||
der_half = 0.5 * DER_TICK_USDC[a] / px[a] * 1e4
|
||||
arb_rt = 2 * (DER_TAKER_BPS + HL_TAKER_BPS + der_half + HL_HALF_SPREAD_BPS)
|
||||
dir_rt = 2 * (DER_TAKER_BPS + der_half)
|
||||
soglie[a] = dict(der_half=der_half, arb=arb_rt, dirz=dir_rt)
|
||||
print(f"\n {a} (ultimo {px[a]:,.0f}) — mezzo spread Deribit lineare = {der_half:.4f} bps (1 tick), "
|
||||
f"HL = {HL_HALF_SPREAD_BPS:.2f} bps")
|
||||
print(f" (i) ARBITRAGGIO cross-venue (4 gambe: apri D+HL, chiudi D+HL)"
|
||||
f" = 2x({DER_TAKER_BPS:.2f}+{HL_TAKER_BPS:.2f}+{der_half:.3f}+{HL_HALF_SPREAD_BPS:.2f})"
|
||||
f" = **{arb_rt:.2f} bps** di andata-ritorno")
|
||||
print(f" (ii) DIREZIONALE su Deribit soltanto (2 gambe, HL usato solo come SEGNALE)"
|
||||
f" = **{dir_rt:.2f} bps**")
|
||||
for tf in ("5m", "15m", "1h", "1d"):
|
||||
d = dec[(a, tf)]
|
||||
print(f" {tf:<4} |scarto| mediano {d['med']:5.2f} bps sd {d['sd']:5.2f} -> "
|
||||
f"serve {arb_rt/max(d['sd'],1e-9):5.1f} sd per pagare l'arb, "
|
||||
f"{dir_rt/max(d['sd'],1e-9):4.1f} sd per pagare il direzionale")
|
||||
print("\n 📌 SOGLIA DI NEGOZIABILITA' CONGELATA QUI: un segnale che promette meno di ~17 bps di")
|
||||
print(" movimento atteso non e' arbitrabile, e meno di ~7 bps non e' nemmeno tradabile su un")
|
||||
print(" venue solo. Il fondo di rumore dello scarto e' di 4-6 bps: **il muro sta sopra la")
|
||||
print(" DEVIAZIONE STANDARD dell'intero fenomeno**, non sopra il suo valore tipico.")
|
||||
return soglie
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 5 — (a) REVERSIONE, con il discriminante rumore-vs-dislocazione
|
||||
# ===========================================================================================
|
||||
def reversione(cache: dict, soglie: dict) -> dict:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [5] (a) LO SCARTO REVERTE? — e la reversione e' RUMORE o DISLOCAZIONE?")
|
||||
print("=" * 100)
|
||||
print(" s(t) = 1e4*ln(p_HL/p_DER). AR(1) sul livello -> mezza-vita.")
|
||||
print(" Poi la decomposizione che conta: r_DER(t+1) = a + bD*s(t) e r_HL(t+1) = a + bH*s(t).")
|
||||
print(" Solo **bD** e' tradabile su Deribit; bH richiede la gamba HL (fuori perimetro).")
|
||||
print(" DISCRIMINANTE dichiarato in A3: la stessa regressione SALTANDO UNA BARRA (r a t+2).")
|
||||
print(" Se bD crolla -> era rumore di osservazione; se sopravvive -> dislocazione vera.")
|
||||
print(" MDE(bD) = 1,96*sd(r)/(sd(s)*sqrt(n)): stampata accanto, perche' un coefficiente")
|
||||
print(" sotto la propria MDE non e' 'piccolo', e' NON MISURATO.\n")
|
||||
print(f" {'asset':<5}{'tf':<5}{'n':>7}{'phi':>7}{'HLbar':>7}{'HLore':>7}"
|
||||
f"{'bD':>9}{'t':>6}{'MDE(bD)':>9}{'bD skip1':>10}{'t':>6}"
|
||||
f"{'E|1sd| bps':>12}{'muro':>7}{'x muro':>8} verso")
|
||||
out = {}
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h", "1d"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
s_ = j["s_bps"].to_numpy()
|
||||
rd = j["r_der"].to_numpy() * 1e4 # bps
|
||||
A = ar1(s_)
|
||||
y, X = rd[1:], np.column_stack([np.ones(len(s_) - 1), s_[:-1]])
|
||||
f1 = ols_hac(y, X)
|
||||
y2, X2 = rd[2:], np.column_stack([np.ones(len(s_) - 2), s_[:-2]])
|
||||
f2 = ols_hac(y2, X2)
|
||||
bD, tD = float(f1["b"][1]), float(f1["t"][1])
|
||||
bD2, tD2 = float(f2["b"][1]), float(f2["t"][1])
|
||||
sd = float(np.std(s_))
|
||||
n = len(s_) - 1
|
||||
mde = 1.96 * float(np.std(rd)) / (sd * np.sqrt(n)) if sd > 0 else np.nan
|
||||
mossa = abs(bD) * sd
|
||||
w = soglie[a]["dirz"]
|
||||
ore = A["half_life"] * TF_MS[tf] / 3_600_000
|
||||
verso = "converge" if bD > 0 else "diverge"
|
||||
if abs(bD) < mde:
|
||||
verso += " (sotto MDE)"
|
||||
print(f" {a:<5}{tf:<5}{len(j):>7,}{A['phi']:>7.3f}{A['half_life']:>7.2f}{ore:>7.1f}"
|
||||
f"{bD:>9.4f}{tD:>6.1f}{mde:>9.4f}{bD2:>10.4f}{tD2:>6.1f}"
|
||||
f"{mossa:>12.2f}{w:>7.2f}{mossa/w:>8.3f} {verso}")
|
||||
out[(a, tf)] = dict(phi=A["phi"], hl=A["half_life"], bD=bD, tD=tD, bD2=bD2, tD2=tD2,
|
||||
mossa=mossa, muro=w, sd=sd, mde=mde)
|
||||
|
||||
print("\n bH (la gamba HL) per completezza — NON eseguibile con questo conto."
|
||||
" Identita' di controllo: bH - bD deve valere (phi-1).")
|
||||
print(f" {'asset':<5}{'tf':<5}{'bH':>9}{'t':>7}{'bH-bD':>9}{'phi-1':>9}{'|dif|':>9}")
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "1h", "1d"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
s_ = j["s_bps"].to_numpy()
|
||||
rh = j["r_hl"].to_numpy() * 1e4
|
||||
f = ols_hac(rh[1:], np.column_stack([np.ones(len(s_) - 1), s_[:-1]]))
|
||||
bH = float(f["b"][1])
|
||||
dif = (bH - out[(a, tf)]["bD"]) - (out[(a, tf)]["phi"] - 1.0)
|
||||
print(f" {a:<5}{tf:<5}{bH:>9.4f}{float(f['t'][1]):>7.1f}"
|
||||
f"{bH - out[(a, tf)]['bD']:>9.4f}{out[(a, tf)]['phi'] - 1:>9.4f}{abs(dif):>9.2e}")
|
||||
|
||||
# --- il conto che decide: la strategia MIGLIORE POSSIBILE su questo segnale ---------------
|
||||
print("\n LA STRATEGIA IN-SAMPLE-OTTIMA (massimamente generosa: il SEGNO di bD e' preso")
|
||||
print(" dagli stessi dati, la posizione e' gia' scalata al meglio, niente ritardo di")
|
||||
print(" esecuzione). pos(t) = clip(sgn(bD)*s(t)/sd(s), -1, +1); pnl = pos*r_DER(t+1);")
|
||||
print(" costo = |Dpos| * (taker Deribit + mezzo spread) su OGNI barra.")
|
||||
print(" In piu' la stessa strategia RITARDATA DI UNA BARRA (l'unica versione che non si")
|
||||
print(" finanzia col proprio rumore di osservazione): se il lordo crolla li', il lordo")
|
||||
print(" della prima colonna era bid-ask bounce, non informazione.")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'barre/anno':>11}{'turnover/anno':>14}{'Sh LORDO':>10}"
|
||||
f"{'Sh LORDO skip1':>16}{'costo %/anno':>14}{'Sh NETTO':>10}{'MDE Sh':>8}")
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h", "1d"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
s_ = j["s_bps"].to_numpy()
|
||||
rd = j["r_der"].to_numpy()
|
||||
sd = float(np.std(s_))
|
||||
sgn = np.sign(out[(a, tf)]["bD"]) or 1.0
|
||||
pos = np.clip(sgn * s_ / sd, -1, 1)
|
||||
pnl_g = pos[:-1] * rd[1:]
|
||||
pnl_s = pos[:-2] * rd[2:] # entrata ritardata di una barra
|
||||
one_way = (DER_TAKER_BPS + soglie[a]["der_half"]) / 1e4
|
||||
dpos = np.abs(np.diff(pos, prepend=pos[0]))[:-1]
|
||||
pnl_n = pnl_g - dpos * one_way
|
||||
bpy = BARS_PER_YEAR[tf]
|
||||
anni = len(j) / bpy
|
||||
def shp(x):
|
||||
return float(np.mean(x) / np.std(x) * np.sqrt(bpy)) if np.std(x) > 0 else np.nan
|
||||
print(f" {a:<5}{tf:<5}{bpy:>11,.0f}{dpos.mean()*bpy:>14,.0f}{shp(pnl_g):>10.2f}"
|
||||
f"{shp(pnl_s):>16.2f}{dpos.mean()*one_way*bpy*100:>14.1f}"
|
||||
f"{shp(pnl_n):>10.2f}{1.96/np.sqrt(anni):>8.2f}")
|
||||
print("\n 📌 La colonna 'costo %/anno' NON e' una stima statistica: e' aritmetica "
|
||||
"(turnover x listino).")
|
||||
print(" La colonna 'Sh LORDO' e' invece sotto la propria MDE su ogni riga intraday: e' il")
|
||||
print(" numero che NON si puo' rivendicare. Il verdetto poggia sulla prima, non sulla seconda.")
|
||||
return out
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 6 — (b) LEAD-LAG: cross-correlazione + causalita' diretta + CONTROLLI
|
||||
# ===========================================================================================
|
||||
def leadlag(cache: dict) -> dict:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [6] (b) UNO DEI DUE VENUE GUIDA? — cross-correlazione E test di causalita' diretto")
|
||||
print("=" * 100)
|
||||
print(" ccf(L) = corr(r_DER[t], r_HL[t-L]). L>0 => HL GUIDA Deribit. L<0 => il contrario.")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'n':>7}" + "".join(f"{f'{L:+d}':>9}" for L in range(-3, 4)))
|
||||
ll = {}
|
||||
for a in ASSETS:
|
||||
for tf in ("5m", "15m", "1h"):
|
||||
j = pair(cache, a, tf).dropna()
|
||||
c = ccf(j["r_der"].to_numpy(), j["r_hl"].to_numpy(), range(-3, 4))
|
||||
print(f" {a:<5}{tf:<5}{len(j):>7,}" + "".join(f"{c[L]:>9.4f}" for L in range(-3, 4)))
|
||||
ll[(a, tf)] = c
|
||||
print(f"\n MDE sulla correlazione a n~5000: 1,96/sqrt(n) = {1.96/np.sqrt(5000):.4f}")
|
||||
|
||||
print("\n CAUSALITA' DIRETTA (Granger con HAC Newey-West, k=4 ritardi, Wald chi2 sul blocco).")
|
||||
print(" 🚨 12 test in questa tabella -> soglia BONFERRONI alpha=0,05/12 = 0,0042, non 0,05.")
|
||||
|
||||
def _granger(j, k=4):
|
||||
"""RIPARAMETRIZZATA: al posto dei ritardi di r_HL uso quelli di d = r_HL - r_DER.
|
||||
|
||||
⚠️ AUTOCORREZIONE: avevo scritto che la parametrizzazione ingenua produce coefficienti
|
||||
gonfiati dalla collinearita' e che la loro somma "non e' una grandezza economica".
|
||||
E' FALSO, e l'algebra lo dice in due righe: `span{r_D, r_H} == span{r_D, r_H-r_D}` con
|
||||
`a_i = a'_i - c'_i` e **`c_i = c'_i`** — il coefficiente del blocco e' letteralmente lo
|
||||
STESSO nelle due scritture, e infatti il controllo numerico sotto da' uno scarto di
|
||||
2,7e-12. La riparametrizzazione compra solo un'assicurazione sul condizionamento (con
|
||||
corr(r_D,r_H)=0,994) e la leggibilita' di `sum c` = **bps di Deribit per bps di
|
||||
divergenza passata**. Cio' che ha davvero riparato la lettura non e' questa, e' la
|
||||
colonna `sd null`: senza di lei una "sd predetta" e' in gran parte gradi di liberta'.
|
||||
"""
|
||||
rd, rh = j["r_der"].to_numpy() * 1e4, j["r_hl"].to_numpy() * 1e4
|
||||
dd = rh - rd
|
||||
n = len(rd) - k
|
||||
if n < 200:
|
||||
return dict(ok=False)
|
||||
L = lambda x, i: x[k - i - 1: k - i - 1 + n] # noqa: E731
|
||||
Xd = np.column_stack([np.ones(n)] + [L(rd, i) for i in range(k)] + [L(dd, i) for i in range(k)])
|
||||
fd = ols_hac(rd[k:], Xd)
|
||||
w1, p1 = wald_block(fd, list(range(1 + k, 1 + 2 * k)))
|
||||
Xh = np.column_stack([np.ones(n)] + [L(rh, i) for i in range(k)] + [L(dd, i) for i in range(k)])
|
||||
fh = ols_hac(rh[k:], Xh)
|
||||
w2, p2 = wald_block(fh, list(range(1 + k, 1 + 2 * k)))
|
||||
cb = fd["b"][1 + k: 1 + 2 * k]
|
||||
contrib = Xd[:, 1 + k: 1 + 2 * k] @ cb # parte di r_DER predetta dalla DIVERGENZA
|
||||
# controllo di equivalenza con la parametrizzazione ingenua (r_HL al posto di d)
|
||||
Xn = np.column_stack([np.ones(n)] + [L(rd, i) for i in range(k)] + [L(rh, i) for i in range(k)])
|
||||
fn = ols_hac(rd[k:], Xn)
|
||||
wn, _ = wald_block(fn, list(range(1 + k, 1 + 2 * k)))
|
||||
# null della sd predetta: con p regressori su n punti, il puro rumore produce gia'
|
||||
# sd(fit) ~ sd(y)*sqrt(p/n). Senza questo confronto una 'sd predetta' e' un artefatto
|
||||
# di gradi di liberta' — e a n=429 con 8 regressori sarebbe quasi tutto artefatto.
|
||||
sd_null = float(np.std(rd[k:])) * np.sqrt(k / n)
|
||||
return dict(ok=True, w1=w1, p1=p1, w2=w2, p2=p2, sum_c=float(cb.sum()),
|
||||
sd_fit=float(np.std(contrib)), sd_null=sd_null, r2=float(fd["r2"]), n=n,
|
||||
w_naive=wn, cnaive=float(fn["b"][1 + k: 1 + 2 * k].sum()))
|
||||
|
||||
def _lettura(p1, p2, alpha=0.05 / 12):
|
||||
if not np.isfinite(p1):
|
||||
return "campione insufficiente"
|
||||
if p1 > alpha and p2 > alpha:
|
||||
return "nessuna direzione"
|
||||
if p1 <= alpha and p2 > alpha:
|
||||
return "HL guida"
|
||||
if p2 <= alpha and p1 > alpha:
|
||||
return "DER guida"
|
||||
return "reciproca"
|
||||
|
||||
gs = []
|
||||
for etichetta, giorni, tfs in (("FINESTRA PIENA di ciascun tf (18 / 52 / 208 gg)", None,
|
||||
("5m", "15m", "1h")),
|
||||
("STESSI 52 giorni (isola il tf dalla finestra)", 52, ("15m", "1h")),
|
||||
("STESSI 18 giorni (idem, al limite del campione)", 18,
|
||||
("5m", "15m", "1h"))):
|
||||
print(f"\n -- {etichetta} --")
|
||||
print(f" {'asset':<5}{'tf':<5}{'n':>7}{'div->DER chi2':>15}{'p':>9}{'div->HL chi2':>14}{'p':>9}"
|
||||
f"{'sum c':>8}{'sd pred':>9}{'sd null':>9}{'muro':>7} lettura (Bonferroni)")
|
||||
for a in ASSETS:
|
||||
for tf in tfs:
|
||||
j = pair(cache, a, tf).dropna()
|
||||
if giorni is not None:
|
||||
j = j[j.index >= j.index[-1] - pd.Timedelta(days=giorni)]
|
||||
g = _granger(j)
|
||||
if not g.get("ok"):
|
||||
print(f" {a:<5}{tf:<5}{len(j):>7,} campione insufficiente")
|
||||
continue
|
||||
w = 2 * (DER_TAKER_BPS + 0.5 * DER_TICK_USDC[a] / float(j['der'].iloc[-1]) * 1e4)
|
||||
print(f" {a:<5}{tf:<5}{g['n']:>7,}{g['w1']:>15.1f}{g['p1']:>9.4f}{g['w2']:>14.1f}"
|
||||
f"{g['p2']:>9.4f}{g['sum_c']:>8.3f}{g['sd_fit']:>9.3f}{g['sd_null']:>9.3f}"
|
||||
f"{w:>7.2f} {_lettura(g['p1'], g['p2'])}")
|
||||
if giorni is None:
|
||||
gs.append((a, tf, etichetta, g))
|
||||
print("\n 📌 Se HL guidasse davvero Deribit, l'effetto sarebbe MASSIMO alla risoluzione piu'")
|
||||
print(" fine e si diluirebbe salendo. Un effetto che compare SOLO a 15m e sparisce sia a 5m")
|
||||
print(" sia a 1h non e' un lead-lag: e' una finestra.")
|
||||
if gs:
|
||||
alpha = 0.05 / 12
|
||||
passa = [x for x in gs if x[3]["p1"] <= alpha or x[3]["p2"] <= alpha]
|
||||
print(f"\n 🚨 La colonna che DECIDE non e' il p-value, e' 'sd pred' — e va letta accanto a")
|
||||
print(f" 'sd null' (con 4 regressori di blocco su n punti il PURO RUMORE produce gia'")
|
||||
print(f" sd(y)*sqrt(4/n) di 'predizione').")
|
||||
for a_, tf_, _, g in sorted(passa, key=lambda x: -x[3]["sd_fit"]):
|
||||
w = 2 * DER_TAKER_BPS
|
||||
print(f" · {a_} {tf_} (p={min(g['p1'], g['p2']):.4f}, passa Bonferroni): sd pred "
|
||||
f"**{g['sd_fit']:.2f} bps** contro {g['sd_null']:.2f} di rumore e {w:.1f} bps di"
|
||||
f" costo -> manca **{w/max(g['sd_fit'],1e-9):.1f}x**")
|
||||
if not passa:
|
||||
print(" · nessuna cella passa Bonferroni sulla finestra piena.")
|
||||
mx = max(gs, key=lambda x: x[3]["sd_fit"])
|
||||
g = mx[3]
|
||||
print(f" Il massimo assoluto di 'sd pred' e' {g['sd_fit']:.2f} bps ({mx[0]} {mx[1]}), ma li'")
|
||||
print(f" il rumore da solo ne fa {g['sd_null']:.2f} e il test NON e' significativo"
|
||||
f" (p={min(g['p1'], g['p2']):.4f}).")
|
||||
# controllo di equivalenza fra le due parametrizzazioni
|
||||
if gs:
|
||||
dif = max(abs(g[3]["w1"] - g[3]["w_naive"]) / max(g[3]["w1"], 1e-9) for g in gs)
|
||||
print(f"\n ✅ Controllo: le due parametrizzazioni (ritardi di r_HL vs ritardi della")
|
||||
print(f" divergenza) danno lo STESSO chi2 — scarto relativo massimo {dif:.2e}. La")
|
||||
print(f" riparametrizzazione non cambia il test, cambia solo la LEGGIBILITA' dei")
|
||||
print(f" coefficienti (somma ingenua fino a {max(abs(g[3]['cnaive']) for g in gs):.2f}, "
|
||||
f"somma leggibile {max(abs(g[3]['sum_c']) for g in gs):.3f}).")
|
||||
|
||||
# ---- CONTROLLI: un rilevatore che non trova nulla e' indistinguibile da uno rotto ----
|
||||
print("\n CONTROLLI OBBLIGATORI (metodo, punto 3) — sugli STESSI stimatori:")
|
||||
rng = np.random.default_rng(823)
|
||||
n = 5000
|
||||
r = rng.normal(0, 0.001, n) # prezzo comune
|
||||
pD = np.exp(np.cumsum(r))
|
||||
# PC1 lead-lag: HL = Deribit RITARDATO di 1 barra + rumore -> Deribit GUIDA (picco a lag -1)
|
||||
pH = np.concatenate([[pD[0]], pD[:-1]]) * np.exp(rng.normal(0, 5e-5, n))
|
||||
rd_, rh_ = np.diff(np.log(pD)) * 1e4, np.diff(np.log(pH)) * 1e4
|
||||
c = ccf(rd_, rh_, range(-3, 4))
|
||||
best = max(c, key=lambda k_: c[k_])
|
||||
print(f" PC1 HL = Deribit ritardato di 1 barra -> picco atteso a lag -1; "
|
||||
f"MISURATO {best:+d} (ccf {c[best]:.3f}) {'OK' if best == -1 else 'ROTTO'}")
|
||||
# PC2 reversione: spread AR(1) noto phi=0.7 -> mezza-vita attesa 1.94 barre
|
||||
phi_true = 0.7
|
||||
e = rng.normal(0, 3.0, n)
|
||||
s_syn = np.zeros(n)
|
||||
for i in range(1, n):
|
||||
s_syn[i] = phi_true * s_syn[i - 1] + e[i]
|
||||
A = ar1(s_syn)
|
||||
hl_att = np.log(0.5) / np.log(phi_true)
|
||||
print(f" PC2 spread AR(1) phi={phi_true} (mezza-vita {hl_att:.2f}) -> "
|
||||
f"MISURATO phi {A['phi']:.3f}, mezza-vita {A['half_life']:.2f} "
|
||||
f"{'OK' if abs(A['phi'] - phi_true) < 0.05 else 'ROTTO'}")
|
||||
# NC: due random walk indipendenti -> nessun lead-lag, nessuna reversione
|
||||
p1_ = np.exp(np.cumsum(rng.normal(0, 0.001, n)))
|
||||
p2_ = np.exp(np.cumsum(rng.normal(0, 0.001, n)))
|
||||
c0 = ccf(np.diff(np.log(p1_)) * 1e4, np.diff(np.log(p2_)) * 1e4, range(-3, 4))
|
||||
mx = max(abs(v) for v in c0.values())
|
||||
print(f" NC due random walk indipendenti -> max |ccf| = {mx:.4f} "
|
||||
f"(soglia rumore {1.96/np.sqrt(n):.4f}) {'OK' if mx < 3*1.96/np.sqrt(n) else 'ROTTO'}")
|
||||
return ll
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 7 — (c) GATE DI REGIME
|
||||
# ===========================================================================================
|
||||
def gate(cache: dict) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [7] (c) LO SCARTO E' UN GATE DI REGIME PER TP01/SKH01?")
|
||||
print("=" * 100)
|
||||
j = {a: pair(cache, a, "1d").dropna() for a in ASSETS}
|
||||
n = min(len(j[a]) for a in ASSETS)
|
||||
anni = n / 365.25
|
||||
mde_sh = 1.96 / np.sqrt(anni)
|
||||
mde_c = 1.96 / np.sqrt(n)
|
||||
print(f"\n Finestra comune: {n} giorni = {anni:.2f} anni (HL 1d parte dal 2024-01-01).")
|
||||
print(f" MDE dichiarato PRIMA: Sharpe {mde_sh:.2f} · correlazione {mde_c:.3f}.")
|
||||
print(" ⚠️ La finestra e' INTERAMENTE dentro l'hold-out 2025-26 + il 2024 -> `marginal_vs_tp01`")
|
||||
print(" non puo' dare ADDS per costruzione (lezione §12): non lo uso, misuro il")
|
||||
print(" CONTENUTO PREDITTIVO direttamente, dove la potenza c'e'.\n")
|
||||
|
||||
print(" 🚨 12 correlazioni in questa tabella -> soglia BONFERRONI |t| > 2,86, non 1,96.\n")
|
||||
print(f" {'asset':<5}{'feature -> bersaglio (t+1)':<42}{'corr':>8}{'t(HAC)':>9}{'MDE':>8} esito")
|
||||
for a in ASSETS:
|
||||
d = j[a]
|
||||
s_ = d["s_bps"].to_numpy()
|
||||
r = d["r_der"].to_numpy() * 1e4
|
||||
absr = np.abs(r)
|
||||
a20 = pd.Series(np.abs(s_)).rolling(20).mean().to_numpy() # causale
|
||||
feats = {"s(t) firmato": s_, "|s(t)|": np.abs(s_), "media20 |s| (causale)": a20}
|
||||
targs = {"rendimento": r, "|rendimento| (vol)": absr}
|
||||
for fn, fv in feats.items():
|
||||
for tn, tv in targs.items():
|
||||
x, y = fv[:-1], tv[1:]
|
||||
m = np.isfinite(x) & np.isfinite(y)
|
||||
if m.sum() < 100:
|
||||
continue
|
||||
c = float(np.corrcoef(x[m], y[m])[0, 1])
|
||||
f = ols_hac(y[m], np.column_stack([np.ones(m.sum()), x[m]]))
|
||||
t = float(f["t"][1])
|
||||
if abs(t) > 2.86:
|
||||
ok = "SEGNALE (regge Bonferroni)"
|
||||
elif abs(c) > mde_c:
|
||||
ok = "sopra MDE ma NON regge Bonferroni"
|
||||
else:
|
||||
ok = "sotto MDE"
|
||||
print(f" {a:<5}{fn + ' -> ' + tn:<42}{c:>8.4f}{t:>9.2f}{mde_c:>8.3f} {ok}")
|
||||
|
||||
# ------------------------------------------------------------------ gate vero su TP01
|
||||
print("\n GATE VERO su TP01 (baseline daily di altlib), finestra comune.")
|
||||
print(" ⚠️ ERRORE MIO, COMMESSO E CORRETTO IN SESSIONE: la prima stesura usava come null")
|
||||
print(" il **de-levering** (base x k a pari vol). Su un gate quel null e' DEGENERE —")
|
||||
print(" `sh(k*base) === sh(base)`, e infatti stampava dSharpe identico nelle due colonne.")
|
||||
print(" E' esattamente il caso avvertito in §12(d). Il null giusto per un GATE e' un")
|
||||
print(" **gate CASUALE con lo stesso ciclo di servizio**: spegne gli stessi giorni di")
|
||||
print(" mercato, ma scelti a caso. Cosi' si misura se il gate spegne i giorni GIUSTI.")
|
||||
try:
|
||||
from scripts.research.alt import altlib as al
|
||||
tp = al.tp01_baseline_daily()
|
||||
except Exception as ex: # pragma: no cover
|
||||
print(f" (baseline TP01 non disponibile: {ex})")
|
||||
return
|
||||
d = j["BTC"]
|
||||
idx = d.index.tz_convert("UTC").normalize()
|
||||
sabs = pd.Series(np.abs(d["s_bps"].to_numpy()), index=idx).rolling(20).mean()
|
||||
tpi = tp.copy()
|
||||
tpi.index = (pd.DatetimeIndex(tpi.index).tz_localize("UTC")
|
||||
if pd.DatetimeIndex(tpi.index).tz is None else pd.DatetimeIndex(tpi.index))
|
||||
tpi.index = tpi.index.normalize()
|
||||
m = pd.concat({"tp": tpi, "g": sabs}, axis=1, join="inner").dropna()
|
||||
if len(m) < 200:
|
||||
print(f" finestra comune troppo corta ({len(m)}) -> non misurabile")
|
||||
return
|
||||
thr = m["g"].expanding(60).median().shift(1) # causale, espandente
|
||||
base = m["tp"].to_numpy()
|
||||
|
||||
def sh(x):
|
||||
x = np.asarray(x, float)
|
||||
return float(np.mean(x) / np.std(x) * np.sqrt(365.25)) if np.std(x) > 0 else np.nan
|
||||
|
||||
rng = np.random.default_rng(66)
|
||||
print(f"\n {'gate':<34}{'on%':>6}{'Sh':>8}{'null casuale (mediana)':>24}{'pctl':>7}"
|
||||
f"{'IC95 del null':>22} esito")
|
||||
for nome, on in (("CALMO acceso (|s| bassa = on)", (m["g"].shift(1) <= thr)),
|
||||
("AGITATO acceso (|s| alta = on)", (m["g"].shift(1) > thr))):
|
||||
onv = on.astype(float).fillna(1.0).to_numpy()
|
||||
gated = base * onv
|
||||
duty = float(np.nanmean(onv))
|
||||
nulls = []
|
||||
for _ in range(2000):
|
||||
# ROTAZIONE CIRCOLARE, non permutazione: conserva il ciclo di servizio **e** la
|
||||
# struttura a run del gate (un gate vero e' fatto di periodi, non di giorni sparsi),
|
||||
# randomizzando solo l'allineamento col rendimento. Null piu' severo e piu' onesto.
|
||||
perm = np.roll(onv, int(rng.integers(1, len(onv))))
|
||||
nulls.append(sh(base * perm))
|
||||
nulls = np.array(nulls)
|
||||
nulls = nulls[np.isfinite(nulls)]
|
||||
pct = float((nulls < sh(gated)).mean() * 100)
|
||||
lo, hi = np.percentile(nulls, [2.5, 97.5])
|
||||
esito = ("il gate spegne i giorni GIUSTI" if pct > 97.5
|
||||
else ("il gate spegne i giorni SBAGLIATI" if pct < 2.5 else "indistinguibile dal caso"))
|
||||
print(f" {nome:<34}{duty*100:>6.0f}{sh(gated):>8.3f}{np.median(nulls):>24.3f}{pct:>7.1f}"
|
||||
f"{f'[{lo:+.3f}, {hi:+.3f}]':>22} {esito}")
|
||||
print(f"\n Sharpe di TP01 SENZA gate sulla stessa finestra: {sh(base):+.3f} (n={len(m)})")
|
||||
print(" 📌 I due gate sono SPECULARI: se uno spegne i giorni sbagliati, l'altro spegne")
|
||||
print(" quelli giusti — ma sceglierlo DOPO aver visto la tabella e' selezione, e va")
|
||||
print(" detto. Cio' che si puo' concludere senza barare e' il FATTO: i giorni a")
|
||||
print(" |scarto| alto NON sono i giorni da evitare per TP01, sono l'opposto.")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# 8 — rinforzo indipendente della taratura di venue_watch
|
||||
# ===========================================================================================
|
||||
def rinforzo(cache: dict) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" [8] SOTTOPRODOTTO — HL come QUARTA referenza per `venue_watch` (soglia 100 bps / 4h)")
|
||||
print("=" * 100)
|
||||
from src.live.venue_watch import PERSIST_HOURS, THRESHOLD_BPS
|
||||
print(f" Soglia in produzione: {THRESHOLD_BPS:.0f} bps persistenti {PERSIST_HOURS}h a segno costante.")
|
||||
print(f"\n {'asset':<5}{'tf':<5}{'n':>7}{'|s|med':>8}{'|s|p99':>9}{'|s|max':>9}"
|
||||
f"{'>100bps':>9}{'episodi 4h':>12}")
|
||||
for a in ASSETS:
|
||||
for tf in ("1h", "1d"):
|
||||
d = pair(cache, a, tf).dropna()
|
||||
s = d["s_bps"]
|
||||
over = (s.abs() > THRESHOLD_BPS).to_numpy()
|
||||
sg = np.sign(s.to_numpy())
|
||||
ep, run, cs = 0, 0, 0
|
||||
for i in range(len(over)):
|
||||
if over[i] and (run == 0 or sg[i] == cs):
|
||||
run = run + 1 if run else 1
|
||||
cs = sg[i]
|
||||
if run == PERSIST_HOURS:
|
||||
ep += 1
|
||||
else:
|
||||
run = 1 if over[i] else 0
|
||||
cs = sg[i] if over[i] else 0
|
||||
print(f" {a:<5}{tf:<5}{len(s):>7,}{s.abs().median():>8.2f}{s.abs().quantile(.99):>9.1f}"
|
||||
f"{s.abs().max():>9.1f}{int(over.sum()):>9}{ep:>12}")
|
||||
print("\n ⚠️ HL NON e' una referenza USD indipendente e non va aggiunta a `venue_watch` senza")
|
||||
print(" verificare la composizione del suo oracolo: se e' costruito da prezzi CEX che")
|
||||
print(" includono coppie USDT, aggiungerla farebbe rientrare l'USDT dalla finestra —")
|
||||
print(" esattamente cio' che la regola «mai USDT» vieta. Qui e' usata come MISURA, non")
|
||||
print(" come referenza di produzione.")
|
||||
print(" 📌 Cio' che invece e' un fatto utile: HL e' l'unico candidato-referenza con piu' di un")
|
||||
print(" mese di storia recuperabile (2,6 anni a 1d, contro il MESE di Kraken) — ma a 1d, e")
|
||||
print(" `venue_watch` decide a 1h. Non ripara la taratura degli 8 anni; puo' fare da")
|
||||
print(" conferma LENTA.")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
def main() -> None:
|
||||
refresh = "--refresh" in sys.argv
|
||||
print("=" * 100)
|
||||
print(" §66 CROSS-VENUE — lo scarto Deribit-vs-Hyperliquid come SEGNALE (STAT-MODE)")
|
||||
print("=" * 100)
|
||||
print(" 🚨 STAT-MODE DICHIARATO IN TESTA: una gamba su Hyperliquid non e' eseguibile con questo")
|
||||
print(" conto (Deribit, ~$635) senza aprire un secondo venue, e la decisione dell'operatore")
|
||||
print(" del 26/07 tiene tutto su Deribit fino a $20k. Il filone si giudica su «esiste il")
|
||||
print(" fenomeno?», non su «e' deployabile?».")
|
||||
cache = load_cache(refresh)
|
||||
try:
|
||||
repliche(cache)
|
||||
certifica_hl(cache)
|
||||
verifica_lag(cache)
|
||||
dec = scomposizione(cache)
|
||||
soglie = muro(cache, dec)
|
||||
rev = reversione(cache, soglie)
|
||||
leadlag(cache)
|
||||
gate(cache)
|
||||
rinforzo(cache)
|
||||
finally:
|
||||
save_cache(cache)
|
||||
|
||||
print("\n" + "=" * 100)
|
||||
print(" VERDETTO")
|
||||
print("=" * 100)
|
||||
kall = max(rev, key=lambda k: rev[k]["mossa"] / rev[k]["muro"])
|
||||
misurate = {k: v for k, v in rev.items() if abs(v["bD"]) > v["mde"]}
|
||||
print(f" Su 8 celle (2 asset x 4 timeframe) **{len(misurate)} hanno |bD| sopra la propria MDE**:"
|
||||
f" {', '.join(f'{k[0]} {k[1]}' for k in misurate) or 'nessuna'}.")
|
||||
if misurate:
|
||||
kb = max(misurate, key=lambda k: misurate[k]["mossa"] / misurate[k]["muro"])
|
||||
v = misurate[kb]
|
||||
arb = soglie[kb[0]]["arb"]
|
||||
print(f" Miglior rapporto segnale/muro fra le celle MISURATE: **{v['mossa']/v['muro']:.3f}** "
|
||||
f"({kb[0]} {kb[1]}: {v['mossa']:.2f} bps attesi a 1 sd contro {v['muro']:.2f} bps di costo"
|
||||
f" su UN venue) -> manca un fattore **{v['muro']/v['mossa']:.1f}x**; per l'arbitraggio a"
|
||||
f" due venue ({arb:.1f} bps) manca **{arb/v['mossa']:.1f}x**.")
|
||||
va = rev[kall]
|
||||
print(f" Il massimo INCONDIZIONATO sarebbe {va['mossa']/va['muro']:.3f} ({kall[0]} {kall[1]}), ma"
|
||||
f" li' |bD|={abs(va['bD']):.2f} contro MDE {va['mde']:.2f}: **non e' piccolo, e' NON MISURATO**"
|
||||
f" — citarlo sarebbe scegliere la cella piu' rumorosa perche' e' la piu' alta.")
|
||||
print(" E ogni numero qui e' OTTIMISTICO tre volte: e' a 1 sd di scarto (non al valore tipico),")
|
||||
print(" il segno di bD e' preso dagli stessi dati, e IGNORA che per entrare bisogna attraversare")
|
||||
print(" gli stessi due book che generano lo scarto — cioe' si paga il rumore che si vuole incassare.")
|
||||
print("\n In EUR/giorno: ZERO. Nessuna configurazione di questo filone e' negoziabile, quindi il")
|
||||
print(" contributo alla rendita e' esattamente 0,00 EUR/giorno, oggi e a ogni capitale fino a")
|
||||
print(" quando il costo per giro non scende sotto il fondo di rumore dei due book.")
|
||||
print("=" * 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,896 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
r0823b_curva_datati.py — filone §65 CURVA-DATATI (ondata 2026-08-23)
|
||||
|
||||
===========================================================================
|
||||
LA DOMANDA
|
||||
===========================================================================
|
||||
L'ondata 1 (§13 BASIS-CALENDAR) ha ricostruito un dataset che il progetto non
|
||||
aveva: **30 futures trimestrali SCADUTI** di Deribit (BTC 240.150 barre orarie /
|
||||
ETH 233.334, dal 2018-09), **col deleveraging 2022 dentro** — la coda che a CC01
|
||||
mancava per costruzione.
|
||||
|
||||
Finora e' stato usato per UNA cosa sola: il **livello** del carry (§13 lo ha
|
||||
scartato come edge; §39 lo ha scartato come veicolo di TP01). **La FORMA della
|
||||
curva — pendenza e curvatura — non e' mai stata guardata.**
|
||||
|
||||
===========================================================================
|
||||
ATTESE DICHIARATE **PRIMA** DI MISURARE (regola 1 del metodo)
|
||||
===========================================================================
|
||||
A1 Il LIVELLO della curva e' funding travestito. §39 ha gia' misurato che il
|
||||
basis dei datati E' il funding del perp (+7,33% implicito contro +6,48%
|
||||
realizzato). Mi aspetto |corr(livello, funding)| ALTA (>0,5).
|
||||
-> se confermata, il ramo "livello" e' chiuso in partenza.
|
||||
A2 La FORMA (pendenza, curvatura) e' un grado di liberta' NUOVO: mi aspetto
|
||||
corr col funding BASSA. E' l'unica ragione per cui questo filone esiste.
|
||||
A3 Nessun ramo produce un candidato. Il filone funding e' chiuso su QUATTRO
|
||||
lati (carry cross-sectional, price-clock, time-series, affollamento) e §13
|
||||
ha gia' esaurito il primo ordine. Mi aspetto SCARTATO su tutti i rami.
|
||||
A4 Il 2022 e' l'unico regime di stress del campione: mi aspetto che qualunque
|
||||
segnale di curva abbia li' il suo unico anno buono (o il suo unico anno
|
||||
cattivo) -> **scomposizione per anno OBBLIGATORIA prima di credere a
|
||||
qualsiasi aggregato** (lezione SOL del 22/08: 24/24 ancore positive che
|
||||
erano un anno solo).
|
||||
A5 Il roll trimestrale costa. §39: SKH01 sui datati fa 48-57 roll-equivalenti
|
||||
l'anno contro 6,6-8,4 di TP01 -> lo stesso mezzo spread gli costa 7 volte
|
||||
tanto. Mi aspetto che il netto sia molto peggiore del lordo su qualunque
|
||||
cosa ribilanci spesso.
|
||||
A6 MDE: 7,4 anni -> MDE sullo Sharpe ~= 1,96/sqrt(7,4) = **0,72**. Un ramo
|
||||
DELTA-NEUTRO (§13: SE del rendimento annuo 1,79pp, vol 4,9%) non e'
|
||||
rispondibile; un ramo DIREZIONALE (vol 50-80%) lo e' in linea di principio.
|
||||
|
||||
Esito di ciascuna: riportato in fondo, confermata/refutata.
|
||||
|
||||
===========================================================================
|
||||
COME E' COSTRUITA LA CURVA — e perche' COSI'
|
||||
===========================================================================
|
||||
Deribit lista SOLO trimestrali (piu' settimanali/mensili che qui non usiamo):
|
||||
a ogni ora sono vivi 2-5 contratti (**4 nel 73% delle ore**). Il problema e' che
|
||||
la scadenza del PRIMO oscilla fra 0 e 91 giorni (dente di sega deterministico).
|
||||
|
||||
Interpolare a maturita' costante richiede estrapolazione nel 41-70% delle ore
|
||||
(misurato). Quindi la curva e' costruita in **spazio FORWARD**, che non ha il
|
||||
problema:
|
||||
b1 = ln(F1/S) * 365,25/dte1 carry spot->primo (denominatore
|
||||
che si annulla a scadenza: rumoroso)
|
||||
fwd12 = ln(F2/F1) * 365,25/(dte2-dte1) forward carry, finestra ~91g FISSA
|
||||
fwd23, fwd34 idem
|
||||
slope = fwd23 - fwd12 curvatura = fwd34 - 2*fwd23 + fwd12
|
||||
Ogni forward carry e' misurato su una finestra di ~91 giorni SEMPRE, quindi non
|
||||
c'e' denominatore che si annulla e non c'e' dente di sega nell'annualizzazione.
|
||||
Cio' che resta di sega (la finestra del fwd12 PARTE a dte1, che oscilla) e' una
|
||||
proprieta' vera della curva, e viene comunque controllata con un PLACEBO
|
||||
esplicito (un segnale che e' funzione SOLA di dte1).
|
||||
|
||||
📌 Tutto in LOG del rapporto dei prezzi, mai medie aritmetiche di differenze:
|
||||
la media aritmetica contiene (varA - varB)/2, che su questi dati vale
|
||||
1,48-2,60%/anno = 2-4x l'effetto cercato (regola gia' pagata, §39).
|
||||
|
||||
===========================================================================
|
||||
IL LAG — verificato, non assunto (§39: corr 0,996 al lag +1)
|
||||
===========================================================================
|
||||
`get_tradingview_chart_data` etichetta la barra all'INIZIO: il close della barra
|
||||
etichettata T e' il prezzo a T+1h. `get_funding_rate_history` etichetta
|
||||
l'indice all'ISTANTE T. Appaiarli senza lag sfasa di un'ora.
|
||||
Il lag NON e' assunto: e' scelto misurando la sd del basis perp-vs-indice a
|
||||
k = -2..+2 e la convergenza a scadenza. Vedi §0.
|
||||
|
||||
===========================================================================
|
||||
DISCIPLINA
|
||||
===========================================================================
|
||||
* SOLA LETTURA. Nessuna rete: tutto da `data/raw/fut_deribit/` (persistito
|
||||
dall'ondata 1). Nessun ordine, nessuna chiave.
|
||||
* Nessun file di produzione toccato.
|
||||
* Famiglia DICHIARATA PRIMA e contata AL RIALZO: 86 backtest + 5 regressioni.
|
||||
Il deflated-Sharpe e' riportato sia per RAMO sia sull'UNIONE, perche' la
|
||||
stessa griglia da' verdetti diversi a seconda di come la si partiziona (§10,
|
||||
§24): la partizione e' un secondo posto dove barare e' indolore e invisibile.
|
||||
|
||||
USO
|
||||
nice -n 19 timeout 900 uv run python scripts/research/r0823b_curva_datati.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import warnings
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from scipy import stats
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
sys.path.insert(0, str(PROJECT_ROOT / "scripts" / "research" / "alt"))
|
||||
|
||||
import altlib as al # noqa: E402
|
||||
from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio # noqa: E402
|
||||
|
||||
warnings.filterwarnings("ignore", category=RuntimeWarning)
|
||||
|
||||
DATA = PROJECT_ROOT / "data" / "raw" / "fut_deribit"
|
||||
MONTHS = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN",
|
||||
"JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]
|
||||
YR = 365.25
|
||||
ASSETS = ("BTC", "ETH")
|
||||
HOLDOUT = al.HOLDOUT
|
||||
SIG_HOUR = 22 # ora di lettura della curva: nota a 23:00 UTC, un'ora
|
||||
# PRIMA della chiusura della barra giornaliera -> causale
|
||||
# con margine. La sensibilita' all'ora e' misurata in §6.
|
||||
|
||||
# ---- famiglia DICHIARATA PRIMA (contata al rialzo) ------------------------
|
||||
VARS_A = ("b1", "fwd12", "slope", "slope_o", "curv") # 5
|
||||
ZWINS = (90, 180, 365) # 3
|
||||
SIGNS = (+1, -1) # 2
|
||||
MAPS = ("sgn", "lin") # 2 -> 60 celle
|
||||
VARS_D = ("fwd12", "slope_o", "curv") # 3
|
||||
PCTLS = (0.30, 0.50, 0.70) # 3
|
||||
DIRS = (+1, -1) # 2 -> 18 celle
|
||||
VARS_B = ("curv", "slope_o") # 2
|
||||
ZWINS_B = (90, 365) # 2
|
||||
SIGNS_B = (+1, -1) # 2 -> 8 celle
|
||||
N_DECLARED_BT = 60 + 18 + 8 # 86 backtest
|
||||
N_DECLARED_REG = 5 # 5 regressioni ramo C
|
||||
|
||||
FEE_SIDE = al.FEE_SIDE # 5 bps/lato: la convenzione dei backtest del progetto
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "=" * 92)
|
||||
if t:
|
||||
print(t)
|
||||
print("=" * 92)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# §0 DATO — caricamento, LAG verificato, certificazione
|
||||
# ===========================================================================
|
||||
def expiry_of(name: str) -> pd.Timestamp:
|
||||
_, tag = name.split("-")
|
||||
return pd.Timestamp(2000 + int(tag[5:]), MONTHS.index(tag[2:5]) + 1,
|
||||
int(tag[:2]), 8, tz="UTC")
|
||||
|
||||
|
||||
def load_contracts(asset: str):
|
||||
closes, exps, vols = {}, {}, {}
|
||||
for f in sorted(DATA.glob(f"{asset}-*.parquet")):
|
||||
nm = f.stem
|
||||
df = pd.read_parquet(f)
|
||||
if len(df) < 200:
|
||||
continue
|
||||
s = df.set_index("ts")["close"].astype(float)
|
||||
s = s[s > 0]
|
||||
s.index = s.index.tz_convert("UTC")
|
||||
v = df.set_index("ts")["volume"].astype(float)
|
||||
v.index = v.index.tz_convert("UTC")
|
||||
e = expiry_of(nm)
|
||||
s = s[s.index < e - pd.Timedelta(hours=2)] # esclude l'ora di settlement
|
||||
closes[nm], exps[nm], vols[nm] = s, e, v
|
||||
return closes, exps, vols
|
||||
|
||||
|
||||
def load_fund(asset: str) -> pd.DataFrame:
|
||||
f = pd.read_parquet(DATA / f"fund_{asset}.parquet").set_index("ts").sort_index()
|
||||
f.index = f.index.tz_convert("UTC")
|
||||
return f
|
||||
|
||||
|
||||
def lag_check(asset: str) -> int:
|
||||
"""Sceglie il lag MISURANDOLO (§39: appaiare due serie dello stesso progetto con
|
||||
convenzioni di etichettatura diverse e' un bug gia' pagato). Ritorna il lag in ore."""
|
||||
fund = load_fund(asset)
|
||||
idx = fund["index"].astype(float)
|
||||
p = al.get(asset, "1h")
|
||||
perp = pd.Series(p["close"].values.astype(float),
|
||||
index=pd.DatetimeIndex(pd.to_datetime(p["datetime"], utc=True)))
|
||||
out = {}
|
||||
for k in (-2, -1, 0, 1, 2):
|
||||
ii = idx.copy()
|
||||
ii.index = ii.index - pd.Timedelta(hours=k)
|
||||
j = pd.concat({"p": perp, "i": ii}, axis=1, join="inner").dropna()
|
||||
b = np.log(j["p"] / j["i"]) * 1e4
|
||||
out[k] = (len(j), float(b.median()), float(b.std()))
|
||||
best = min(out, key=lambda k: out[k][2])
|
||||
print(f" {asset}: basis perp-vs-indice per lag (sd = il criterio)")
|
||||
for k, (n, m, s) in out.items():
|
||||
mark = " <- SCELTO (sd minima)" if k == best else ""
|
||||
print(f" lag {k:+d}h n={n:,} mediana {m:+7.2f} bps sd {s:8.2f} bps{mark}")
|
||||
return best
|
||||
|
||||
|
||||
def build_curve(asset: str, lag_h: int) -> pd.DataFrame:
|
||||
closes, exps, vols = load_contracts(asset)
|
||||
fund = load_fund(asset)
|
||||
idx = fund["index"].astype(float)
|
||||
f1h = fund["f1h"].astype(float)
|
||||
wide = pd.DataFrame(closes).sort_index()
|
||||
S = idx.reindex(wide.index + pd.Timedelta(hours=lag_h))
|
||||
S.index = wide.index
|
||||
keep = S.notna()
|
||||
wide, S = wide[keep], S[keep]
|
||||
DTE = pd.DataFrame({nm: (exps[nm] - wide.index).total_seconds() / 86400.0
|
||||
for nm in wide.columns}, index=wide.index).where(wide.notna())
|
||||
dt_v, px_v, sv = DTE.values, wide.values, S.values
|
||||
n = len(wide)
|
||||
out = np.full((n, 6), np.nan)
|
||||
for i in range(n):
|
||||
m = np.isfinite(dt_v[i]) & np.isfinite(px_v[i]) & (dt_v[i] > 0.5)
|
||||
d, p = dt_v[i][m], px_v[i][m]
|
||||
o = np.argsort(d)
|
||||
d, p = d[o], p[o]
|
||||
k = len(d)
|
||||
out[i, 5] = k
|
||||
if k >= 1:
|
||||
out[i, 0] = d[0]
|
||||
out[i, 1] = np.log(p[0] / sv[i]) * YR / d[0]
|
||||
if k >= 2:
|
||||
out[i, 2] = np.log(p[1] / p[0]) * YR / (d[1] - d[0])
|
||||
if k >= 3:
|
||||
out[i, 3] = np.log(p[2] / p[1]) * YR / (d[2] - d[1])
|
||||
if k >= 4:
|
||||
out[i, 4] = np.log(p[3] / p[2]) * YR / (d[3] - d[2])
|
||||
C = pd.DataFrame(out, index=wide.index,
|
||||
columns=["dte1", "b1", "fwd12", "fwd23", "fwd34", "nlive"])
|
||||
C["slope"] = C["fwd23"] - C["fwd12"]
|
||||
C["curv"] = C["fwd34"] - 2 * C["fwd23"] + C["fwd12"]
|
||||
C["fund24"] = f1h.reindex(C.index).rolling(24).mean() * 24 * YR
|
||||
C["S"] = S
|
||||
return C
|
||||
|
||||
|
||||
def causal_orth(y: pd.Series, x: pd.Series, min_obs: int = 180) -> pd.Series:
|
||||
"""Residuo di y su x con beta stimato SOLO sul passato (media espandente, shift 1).
|
||||
Se il beta usasse tutto il campione sarebbe look-ahead che `causality_ok` non vede."""
|
||||
j = pd.concat({"y": y, "x": x}, axis=1)
|
||||
v = j.notna().all(axis=1)
|
||||
yy = j["y"].where(v)
|
||||
xx = j["x"].where(v)
|
||||
n = v.astype(float).cumsum().shift(1)
|
||||
sx = xx.fillna(0).cumsum().shift(1)
|
||||
sy = yy.fillna(0).cumsum().shift(1)
|
||||
sxx = (xx.fillna(0) ** 2).cumsum().shift(1)
|
||||
sxy = (xx.fillna(0) * yy.fillna(0)).cumsum().shift(1)
|
||||
cov = sxy / n - (sx / n) * (sy / n)
|
||||
var = sxx / n - (sx / n) ** 2
|
||||
beta = (cov / var).where(n >= min_obs)
|
||||
alpha = (sy / n) - beta * (sx / n)
|
||||
return (yy - (alpha + beta * xx)).where(n >= min_obs)
|
||||
|
||||
|
||||
def daily_curve(asset: str, C: pd.DataFrame, hour: int = SIG_HOUR) -> pd.DataFrame:
|
||||
d = C[C.index.hour == hour].copy()
|
||||
d.index = d.index.normalize()
|
||||
d = d[~d.index.duplicated(keep="last")]
|
||||
d["slope_o"] = causal_orth(d["slope"], d["fwd12"])
|
||||
return d
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# SEGNALI E BACKTEST
|
||||
# ===========================================================================
|
||||
def zscore(s: pd.Series, w: int) -> pd.Series:
|
||||
m = s.rolling(w, min_periods=max(30, w // 2)).mean()
|
||||
sd = s.rolling(w, min_periods=max(30, w // 2)).std()
|
||||
return ((s - m) / sd).replace([np.inf, -np.inf], np.nan)
|
||||
|
||||
|
||||
def direction_from(z: pd.Series, sign: int, mp: str) -> pd.Series:
|
||||
if mp == "sgn":
|
||||
d = np.sign(z)
|
||||
else:
|
||||
d = np.clip(z / 2.0, -1.0, 1.0)
|
||||
return (sign * d).fillna(0.0)
|
||||
|
||||
|
||||
def _align_to_bars(df: pd.DataFrame, s: pd.Series, fill: float = 0.0) -> np.ndarray:
|
||||
idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
|
||||
return s.reindex(idx).fillna(fill).values.astype(float)
|
||||
|
||||
|
||||
def _ms(idx: pd.DatetimeIndex) -> np.ndarray:
|
||||
"""Epoca in MILLISECONDI, esplicita.
|
||||
⚠️ `idx.view("int64")` NON e' sicuro: i parquet dei datati hanno risoluzione
|
||||
`datetime64[ms]` e `al.get` `[ns]` -> la stessa riga di codice ritorna ms in un
|
||||
posto e ns nell'altro, senza eccezione e senza NaN. E' la famiglia di bug
|
||||
codificata il 01/07 (`.view("int64")` su indici tz-aware non-ns) e ripagata in
|
||||
§35. Qui e' stata ripagata una TERZA volta, da me, e l'ha resa visibile un
|
||||
`n=0` — non un numero sbagliato."""
|
||||
return (pd.DatetimeIndex(idx).tz_convert("UTC").as_unit("ns")
|
||||
.astype("int64") // 10 ** 6)
|
||||
|
||||
|
||||
def expanding_pctl(s: pd.Series, min_obs: int = 180) -> pd.Series:
|
||||
"""Percentile ESPANDENTE causale: quota delle osservazioni STRETTAMENTE
|
||||
precedenti che stanno sotto quella corrente. O(n log n) con bisect."""
|
||||
import bisect
|
||||
vals, seen, out = s.values.astype(float), [], np.full(len(s), np.nan)
|
||||
for i, v in enumerate(vals):
|
||||
if np.isfinite(v):
|
||||
if len(seen) >= min_obs:
|
||||
out[i] = bisect.bisect_right(seen, v) / len(seen)
|
||||
bisect.insort(seen, v)
|
||||
return pd.Series(out, index=s.index)
|
||||
|
||||
|
||||
def cell_daily_A(dcur: dict, var: str, w: int, sign: int, mp: str,
|
||||
fee_side: float = FEE_SIDE) -> pd.Series:
|
||||
"""Serie giornaliera netta 50/50 BTC+ETH del ramo A (stessa convenzione di
|
||||
`altlib.candidate_daily`: eval_weights fa lo shift, non si puo' fare leak)."""
|
||||
ser = {}
|
||||
for a in ASSETS:
|
||||
df = al.get(a, "1d")
|
||||
d = dcur[a]
|
||||
dirn = direction_from(zscore(d[var], w), sign, mp)
|
||||
tgt = al.vol_target(_align_to_bars(df, dirn), df, target_vol=0.20,
|
||||
vol_win_days=30, leverage_cap=2.0)
|
||||
ev = al.eval_weights(df, tgt, fee_side=fee_side)
|
||||
ser[a] = pd.Series(ev["net"], index=ev["idx"])
|
||||
J = pd.concat(ser, axis=1, join="inner").fillna(0.0)
|
||||
return al._to_daily(0.5 * J[ASSETS[0]] + 0.5 * J[ASSETS[1]])
|
||||
|
||||
|
||||
def tp01_targets() -> dict:
|
||||
tp = TrendPortfolio(**CANONICAL)
|
||||
return {a: tp.target_series(al.get(a, "1d")) for a in ASSETS}
|
||||
|
||||
|
||||
def cell_daily_D(dcur: dict, tgts: dict, var: str, pctl: float, dirn: int,
|
||||
g_off: float = 0.0, fee_side: float = FEE_SIDE,
|
||||
t0: pd.Timestamp | None = None) -> pd.Series:
|
||||
"""TP01 moltiplicato per un gate di curva. Il percentile e' ESPANDENTE e causale."""
|
||||
ser = {}
|
||||
for a in ASSETS:
|
||||
df = al.get(a, "1d")
|
||||
d = dcur[a]
|
||||
rk = expanding_pctl(d[var])
|
||||
on = (rk >= pctl) if dirn > 0 else (rk <= pctl)
|
||||
g = pd.Series(np.where(on.fillna(False), 1.0, g_off), index=d.index)
|
||||
g[rk.isna()] = 1.0 # prima del warm-up: gate INATTIVO
|
||||
# ⚠️ fill=1.0, NON 0.0: fuori dalla finestra della curva il gate non esiste,
|
||||
# e riempire a zero spegnerebbe TP01 su meta' della sua storia. E' il difetto
|
||||
# che il controllo d'identita' ha catturato (max|diff| 2,4e-02, non 0).
|
||||
tgt = tgts[a] * _align_to_bars(df, g, fill=1.0)
|
||||
ev = al.eval_weights(df, tgt, fee_side=fee_side)
|
||||
ser[a] = pd.Series(ev["net"], index=ev["idx"])
|
||||
J = pd.concat(ser, axis=1, join="inner").fillna(0.0)
|
||||
out = al._to_daily(0.5 * J[ASSETS[0]] + 0.5 * J[ASSETS[1]])
|
||||
return out[out.index >= t0] if t0 is not None else out
|
||||
|
||||
|
||||
def beta_baseline(fee_side: float = FEE_SIDE) -> pd.Series:
|
||||
"""LONG SEMPRE, vol-targeted 20% con lo stesso motore: e' il benchmark che il
|
||||
ramo A deve battere. Senza di lui una cella 'quasi sempre lunga' su un campione
|
||||
2019-2026 con due tori sembra un segnale e non lo e'."""
|
||||
ser = {}
|
||||
for a in ASSETS:
|
||||
df = al.get(a, "1d")
|
||||
tgt = al.vol_target(np.ones(len(df)), df, target_vol=0.20,
|
||||
vol_win_days=30, leverage_cap=2.0)
|
||||
ev = al.eval_weights(df, tgt, fee_side=fee_side)
|
||||
ser[a] = pd.Series(ev["net"], index=ev["idx"])
|
||||
J = pd.concat(ser, axis=1, join="inner").fillna(0.0)
|
||||
return al._to_daily(0.5 * J[ASSETS[0]] + 0.5 * J[ASSETS[1]])
|
||||
|
||||
|
||||
def mean_pos(dcur: dict, var: str, w: int, sign: int, mp: str) -> float:
|
||||
"""Esposizione media della cella: se e' ~1 la cella e' un LONG travestito."""
|
||||
v = []
|
||||
for a in ASSETS:
|
||||
df = al.get(a, "1d")
|
||||
dirn = direction_from(zscore(dcur[a][var], w), sign, mp)
|
||||
v.append(float(np.mean(_align_to_bars(df, dirn))))
|
||||
return float(np.mean(v))
|
||||
|
||||
|
||||
def sh(s) -> float:
|
||||
return al._sh(s)
|
||||
|
||||
|
||||
def dd(s) -> float:
|
||||
return al._dd_ret(s)
|
||||
|
||||
|
||||
def split(s: pd.Series):
|
||||
return s[s.index < HOLDOUT], s[s.index >= HOLDOUT]
|
||||
|
||||
|
||||
def per_year(s: pd.Series) -> dict:
|
||||
return {int(y): round(sh(g), 2) for y, g in s.groupby(s.index.year) if len(g) > 60}
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
def main() -> None:
|
||||
print(__doc__.split("USO")[0])
|
||||
|
||||
# ---------------------------------------------------------------- §0
|
||||
hr("§0 IL DATO — lag MISURATO (non assunto), curva, certificazione")
|
||||
lags = {}
|
||||
for a in ASSETS:
|
||||
lags[a] = lag_check(a)
|
||||
lag = lags["BTC"]
|
||||
print(f"\n -> lag adottato: +{lag}h su ENTRAMBI gli asset "
|
||||
f"(BTC {lags['BTC']:+d}, ETH {lags['ETH']:+d})")
|
||||
|
||||
curves, dcur = {}, {}
|
||||
for a in ASSETS:
|
||||
C = build_curve(a, lag)
|
||||
curves[a] = C
|
||||
dcur[a] = daily_curve(a, C)
|
||||
nl = C["nlive"].value_counts().sort_index()
|
||||
print(f"\n {a}: {len(C):,} ore {C.index.min().date()} .. {C.index.max().date()}"
|
||||
f" ({(C.index.max()-C.index.min()).days/365.25:.1f} anni)")
|
||||
print(f" contratti vivi/ora: " +
|
||||
" ".join(f"{int(k)}:{v/len(C)*100:.0f}%" for k, v in nl.items()))
|
||||
print(f" giorni con curva (ora {SIG_HOUR:02d}): {len(dcur[a]):,}")
|
||||
|
||||
print("\n CONVERGENZA A SCADENZA |ln(F/indice)| ultime 4h — col lag e senza")
|
||||
for a in ASSETS:
|
||||
closes, exps, _ = load_contracts(a)
|
||||
idx = load_fund(a)["index"].astype(float)
|
||||
for k in (0, lag):
|
||||
v = []
|
||||
for nm, s in closes.items():
|
||||
tail = s[s.index >= exps[nm] - pd.Timedelta(hours=6)]
|
||||
if not len(tail):
|
||||
continue
|
||||
ii = idx.reindex(tail.index + pd.Timedelta(hours=k))
|
||||
x = np.abs(np.log(tail.values / ii.values)) * 1e4
|
||||
x = x[np.isfinite(x)]
|
||||
if len(x):
|
||||
v.append(float(np.median(x)))
|
||||
print(f" {a} lag +{k}h: mediana {np.median(v):5.1f} bps (n={len(v)})")
|
||||
print(" ⚠️ §13 pubblico' 33-47 bps: era calcolato SENZA il lag (merge_asof 'nearest').")
|
||||
print(" Correzione a un numero pubblicato: il dato e' migliore di come e' stato descritto.")
|
||||
|
||||
# ---------------------------------------------------------------- §1
|
||||
hr("§1 LA FORMA DELLA CURVA — livello, pendenza, curvatura (mai guardate prima)")
|
||||
print(" Tutte le grandezze sono carry ANNUALIZZATI in log; fwdXY = forward carry")
|
||||
print(" su finestra ~91g FISSA (niente denominatore che si annulla).\n")
|
||||
for a in ASSETS:
|
||||
C = curves[a]
|
||||
print(f" --- {a} ---")
|
||||
print(" var n mediana p05 p95 sd")
|
||||
for c in ("b1", "fwd12", "fwd23", "fwd34", "slope", "curv", "fund24"):
|
||||
s = C[c].dropna()
|
||||
print(f" {c:9s} {len(s):7,} {s.median()*100:8.2f}% {s.quantile(.05)*100:9.2f}% "
|
||||
f"{s.quantile(.95)*100:9.2f}% {s.std()*100:8.2f}%")
|
||||
|
||||
# ---------------------------------------------------------------- §2
|
||||
hr("§2 PRIOR A1/A2 — la curva e' funding travestito? (si misura PRIMA di backtestare)")
|
||||
print(" Attesa dichiarata: LIVELLO si (|corr|>0,5), FORMA no.\n")
|
||||
corr_tab = {}
|
||||
for a in ASSETS:
|
||||
d = dcur[a]
|
||||
print(f" --- {a} (giornaliero, n={len(d):,}) ---")
|
||||
for c in ("b1", "fwd12", "fwd23", "fwd34", "slope", "slope_o", "curv"):
|
||||
j = d[[c, "fund24"]].dropna()
|
||||
r = float(j[c].corr(j["fund24"]))
|
||||
corr_tab[(a, c)] = r
|
||||
tag = " <- LIVELLO: funding travestito" if abs(r) > 0.5 else ""
|
||||
print(f" corr({c:8s}, funding24h) = {r:+.3f} n={len(j):,}{tag}")
|
||||
j = d[["slope", "fwd12"]].dropna()
|
||||
print(f" [contorno] corr(slope, livello) = {j['slope'].corr(j['fwd12']):+.3f}"
|
||||
f" -> la pendenza GREZZA e' in gran parte il livello col segno rovesciato")
|
||||
print("\n CONTROLLO POSITIVO del rilevatore di correlazione (un rilevatore che non trova")
|
||||
print(" nulla e' indistinguibile da uno rotto): rumore bianco vs funding, e funding vs se stesso")
|
||||
rng = np.random.default_rng(20260823)
|
||||
d = dcur["BTC"]
|
||||
noise = pd.Series(rng.normal(size=len(d)), index=d.index)
|
||||
j = pd.concat({"n": noise, "f": d["fund24"]}, axis=1).dropna()
|
||||
print(f" corr(rumore, funding) = {j['n'].corr(j['f']):+.3f} (atteso ~0)")
|
||||
print(f" corr(funding, funding) = {1.0:+.3f} (atteso +1)")
|
||||
print("\n 📌 ESITO: A1 CONFERMATA (b1 +0,6 su entrambi), A2 CONFERMATA — e in modo piu'")
|
||||
print(" forte dell'atteso: la pendenza ORTOGONALIZZATA al livello e la curvatura")
|
||||
print(" sono praticamente scorrelate dal funding. **La forma e' un grado di")
|
||||
print(" liberta' nuovo: il ramo non e' chiuso in partenza.**")
|
||||
|
||||
# ---------------------------------------------------------------- §3
|
||||
hr("§3 PRE-TEST DI REGRESSIONE — e il suo CONTROLLO POSITIVO, che FALLISCE")
|
||||
print(" Regressione dei rendimenti spot futuri sulla variabile di curva (z-unit).")
|
||||
print(" t corretto grossolanamente per sovrapposizione: t_naive/sqrt(h).\n")
|
||||
reg_rows = []
|
||||
for a in ASSETS:
|
||||
d = dcur[a]
|
||||
lp = np.log(d["S"])
|
||||
print(f" --- {a} ---")
|
||||
print(" var h=5g h=21g h=63g")
|
||||
for v in list(VARS_A) + ["mom90(CTRL+)"]:
|
||||
if v.startswith("mom90"):
|
||||
x0 = lp - lp.shift(90)
|
||||
else:
|
||||
x0 = d[v]
|
||||
row = f" {v:11s}"
|
||||
for h in (5, 21, 63):
|
||||
fw = lp.shift(-h) - lp
|
||||
jj = pd.concat([x0, fw], axis=1).dropna()
|
||||
jj.columns = ["x", "y"]
|
||||
if len(jj) < 100 or jj["x"].std() == 0:
|
||||
row += " n/a "
|
||||
continue
|
||||
xz = (jj["x"] - jj["x"].mean()) / jj["x"].std()
|
||||
sl, ic, rr, pv, se = stats.linregress(xz, jj["y"])
|
||||
t = sl / se / np.sqrt(h)
|
||||
row += f" {sl*100:+6.2f}%(t{t:+5.2f})"
|
||||
if not v.startswith("mom90"):
|
||||
reg_rows.append(dict(asset=a, var=v, h=h, beta=sl, t=t))
|
||||
print(row)
|
||||
print("\n 🚨 IL CONTROLLO POSITIVO NON PASSA: il momentum a 90 giorni — il segnale che")
|
||||
print(" REGGE il 75% del libro live (TP01, Sharpe FULL 1,31 = t~3,6 su 7,4 anni) —")
|
||||
print(" in questa lente da |t| 0,4-1,4. **La regressione predittiva univariata su")
|
||||
print(" rendimenti crypto NON HA POTENZA a questo campione**: un t basso qui non e'")
|
||||
print(" evidenza di assenza. -> il ramo si giudica sui BACKTEST (§4-§5), non su questi t.")
|
||||
print(" (Le regressioni restano a registro: 5 variabili x 3 orizzonti x 2 asset.)")
|
||||
|
||||
# ---------------------------------------------------------------- §4
|
||||
hr("§4 RAMO A — la curva come segnale DIREZIONALE (60 celle dichiarate)")
|
||||
B = al.tp01_baseline_daily()
|
||||
print(f" ✅ REPLICA prima di produrre numeri nuovi: TP01 baseline 50/50")
|
||||
print(f" Sharpe FULL {sh(B):.3f} (pubblicato ~1,30) HOLD {sh(B[B.index>=HOLDOUT]):.3f}")
|
||||
print(f" ⚠️ l'hold-out pubblicato e' ~0,31-0,44 a seconda del VINTAGE di data/raw/")
|
||||
print(f" (gitignored, riscritto ogni notte): la terza cifra non e' confrontabile.\n")
|
||||
|
||||
BB = beta_baseline()
|
||||
bi, bh = split(BB)
|
||||
print(f" BENCHMARK BETA (long sempre, vol-target 20%, stesso motore):")
|
||||
print(f" Sharpe IS {sh(bi):+.3f} FULL {sh(BB):+.3f} HOLD {sh(bh):+.3f}"
|
||||
f" maxDD {dd(BB)*100:.1f}%")
|
||||
print(" ⚠️ e' IL benchmark del ramo A: su 2019-2026 (due tori) una cella che sta")
|
||||
print(" long quasi sempre eredita questo Sharpe senza contenere informazione.\n")
|
||||
|
||||
rowsA = []
|
||||
for var in VARS_A:
|
||||
for w in ZWINS:
|
||||
for sg in SIGNS:
|
||||
for mp in MAPS:
|
||||
s = cell_daily_A(dcur, var, w, sg, mp)
|
||||
ins, hol = split(s)
|
||||
rowsA.append(dict(var=var, w=w, sign=sg, map=mp, daily=s,
|
||||
is_sh=sh(ins) if len(ins) > 60 else np.nan,
|
||||
full=sh(s), hold=sh(hol) if len(hol) > 60 else np.nan,
|
||||
dd=dd(s)))
|
||||
assert len(rowsA) == 60, len(rowsA)
|
||||
print(f" celle valutate: {len(rowsA)} (dichiarate 60)")
|
||||
validA = [r for r in rowsA if np.isfinite(r["is_sh"])]
|
||||
chosenA = max(validA, key=lambda r: r["is_sh"])
|
||||
print(f" distribuzione dei 60 Sharpe FULL: mediana {np.median([r['full'] for r in rowsA]):+.3f}"
|
||||
f" min {min(r['full'] for r in rowsA):+.3f} max {max(r['full'] for r in rowsA):+.3f}")
|
||||
print(f" frazione di celle con FULL>0: {np.mean([r['full']>0 for r in rowsA]):.0%}"
|
||||
f" con HOLD>0: {np.mean([r['hold']>0 for r in rowsA]):.0%}")
|
||||
print("\n CELLA SCELTA IN-SAMPLE-ONLY (nessuna occhiata all'hold-out):")
|
||||
print(f" {chosenA['var']} w={chosenA['w']} sign={chosenA['sign']:+d} map={chosenA['map']}"
|
||||
f" Sh IS {chosenA['is_sh']:+.3f} FULL {chosenA['full']:+.3f}"
|
||||
f" HOLD {chosenA['hold']:+.3f} maxDD {chosenA['dd']*100:.1f}%")
|
||||
best_hold = max(validA, key=lambda r: r["hold"])
|
||||
print(f" (per contrasto, la cella a MASSIMO hold-out — che NON e' selezionabile —:")
|
||||
print(f" {best_hold['var']} w={best_hold['w']} sign={best_hold['sign']:+d} "
|
||||
f"map={best_hold['map']} IS {best_hold['is_sh']:+.3f} HOLD {best_hold['hold']:+.3f})")
|
||||
print("\n top-8 per Sharpe IN-SAMPLE (pos = esposizione media: ~1 => LONG travestito)")
|
||||
print(" var w sgn map ShIS ShFULL ShHOLD maxDD pos")
|
||||
for r in sorted(validA, key=lambda r: r["is_sh"], reverse=True)[:8]:
|
||||
mp_ = mean_pos(dcur, r["var"], r["w"], r["sign"], r["map"])
|
||||
print(f" {r['var']:9s} {r['w']:4d} {r['sign']:+2d} {r['map']:4s}"
|
||||
f" {r['is_sh']:+7.3f} {r['full']:+8.3f} {r['hold']:+7.3f} {r['dd']*100:7.1f}%"
|
||||
f" {mp_:+6.2f}")
|
||||
print(f" 🚨 NESSUNA delle 60 celle batte il benchmark beta ({sh(BB):+.3f} FULL): la")
|
||||
print(f" migliore in-sample fa {chosenA['full']:+.3f}, la migliore in assoluto "
|
||||
f"{max(r['full'] for r in rowsA):+.3f}.")
|
||||
|
||||
allA = [r["full"] for r in rowsA]
|
||||
dsrA, sr0A = al.deflated_sharpe(chosenA["full"], allA, chosenA["daily"])
|
||||
print(f"\n deflated-Sharpe (ramo A, N=60): {dsrA:.3f} "
|
||||
f"(massimo atteso dal PURO RUMORE {sr0A:+.3f}) "
|
||||
f"{'PASS' if dsrA >= 0.95 else 'FAIL'}")
|
||||
|
||||
mgA = al.marginal_vs_tp01(chosenA["daily"])
|
||||
print(f" marginal_vs_tp01: {mgA['marginal_verdict']} corr {mgA['corr_full']:+.3f} "
|
||||
f"beta {mgA['beta_to_tp01']:+.3f} alpha {mgA['alpha_ann']*100:+.2f}%/anno")
|
||||
print(f" uplift w25 FULL {mgA['blends']['w25']['uplift_full']:+.3f} "
|
||||
f"HOLD {mgA['blends']['w25']['uplift_hold']:+.3f} "
|
||||
f"robust_oos {mgA['robust_oos']} has_insample_edge {mgA['has_insample_edge']} "
|
||||
f"is_hedge {mgA['is_hedge']}")
|
||||
earnsA = bool(mgA["marginal_verdict"] == "ADDS" and dsrA >= 0.95)
|
||||
print(f" -> earns_slot_honest (ramo A) = {earnsA}")
|
||||
|
||||
print("\n PER ANNO della cella scelta (A4: un aggregato si scompone prima di crederci):")
|
||||
py = per_year(chosenA["daily"])
|
||||
print(" " + " ".join(f"{y}:{v:+.2f}" for y, v in py.items()))
|
||||
pos = sum(1 for v in py.values() if v > 0)
|
||||
print(f" anni positivi {pos}/{len(py)} 2022 (l'unico stress del campione): "
|
||||
f"{py.get(2022, float('nan')):+.2f}")
|
||||
|
||||
print("\n PLACEBO DEL DENTE DI SEGA (il rischio strutturale di questo dataset):")
|
||||
print(" un segnale che e' funzione SOLA di dte1 (giorni alla prima scadenza) non")
|
||||
print(" contiene informazione di curva. Se battesse la cella scelta, il ramo A")
|
||||
print(" starebbe misurando il calendario dei roll, non la forma della curva.")
|
||||
dsaw = {a: dcur[a].assign(**{"__saw": dcur[a]["dte1"]}) for a in ASSETS}
|
||||
for w in ZWINS:
|
||||
s = cell_daily_A(dsaw, "__saw", w, +1, "lin")
|
||||
s2 = cell_daily_A(dsaw, "__saw", w, -1, "lin")
|
||||
print(f" dte1 w={w:3d}: Sh FULL {sh(s):+.3f} / {sh(s2):+.3f} (segno +/-)"
|
||||
f" pos {mean_pos(dsaw, '__saw', w, +1, 'lin'):+.2f}")
|
||||
print(" 🚨 IL PLACEBO BATTE OGNI CELLA DI CURVA — e la diagnosi e' il contrario di")
|
||||
print(" quella che sembra. I due segni sono SPECCHI quasi esatti e l'esposizione")
|
||||
print(" media e' ~+1: il placebo non sta misurando il dente di sega, sta stando")
|
||||
print(f" LONG, e riproduce il benchmark beta ({sh(BB):+.3f}). Cio' che dimostra e'")
|
||||
print(" piu' severo: **nessun segnale di curva batte 'stai lungo e basta'** su")
|
||||
print(" questo campione. Un placebo va letto sulla sua ESPOSIZIONE prima che sul")
|
||||
print(" suo Sharpe, o si conclude l'opposto.")
|
||||
|
||||
# ---------------------------------------------------------------- §5
|
||||
hr("§5 RAMO D — la curva come GATE DI REGIME su TP01 (18 celle dichiarate)")
|
||||
tgts = tp01_targets()
|
||||
T0 = max(dcur[a].index.min() for a in ASSETS)
|
||||
base_gate = cell_daily_D(dcur, tgts, "fwd12", 0.0, +1) # gate sempre acceso
|
||||
print(f" ✅ CONTROLLO DI IDENTITA': gate sempre acceso vs TP01 baseline sulla finestra comune")
|
||||
j = pd.concat({"g": base_gate, "b": B}, axis=1, join="inner").dropna()
|
||||
print(f" max|diff| = {float((j['g']-j['b']).abs().max()):.2e} "
|
||||
f"Sh {sh(j['g']):.4f} vs {sh(j['b']):.4f}")
|
||||
ref = base_gate[base_gate.index >= T0]
|
||||
rowsD = []
|
||||
for var in VARS_D:
|
||||
for p in PCTLS:
|
||||
for dr in DIRS:
|
||||
s = cell_daily_D(dcur, tgts, var, p, dr, t0=T0)
|
||||
ins, hol = split(s)
|
||||
rowsD.append(dict(var=var, p=p, dir=dr, daily=s,
|
||||
is_sh=sh(ins), full=sh(s), hold=sh(hol), dd=dd(s)))
|
||||
assert len(rowsD) == 18, len(rowsD)
|
||||
chosenD = max(rowsD, key=lambda r: r["is_sh"])
|
||||
ri, rh = split(ref)
|
||||
print(f"\n riferimento (TP01 sulla finestra della curva): IS {sh(ri):+.3f} "
|
||||
f"FULL {sh(ref):+.3f} HOLD {sh(rh):+.3f} maxDD {dd(ref)*100:.1f}%")
|
||||
print(" celle (18): var pctl dir ShIS ShFULL ShHOLD maxDD dShFULL")
|
||||
for r in sorted(rowsD, key=lambda r: r["is_sh"], reverse=True):
|
||||
mark = " <- scelta IS" if r is chosenD else ""
|
||||
print(f" {r['var']:9s} {r['p']:.2f} {r['dir']:+d} {r['is_sh']:+7.3f}"
|
||||
f" {r['full']:+8.3f} {r['hold']:+7.3f} {r['dd']*100:7.1f}% "
|
||||
f"{r['full']-sh(ref):+8.3f}{mark}")
|
||||
allD = [r["full"] for r in rowsD]
|
||||
dsrD, sr0D = al.deflated_sharpe(chosenD["full"], allD, chosenD["daily"])
|
||||
print(f"\n deflated-Sharpe (ramo D, N=18): {dsrD:.3f} (rumore max atteso {sr0D:+.3f}) "
|
||||
f"{'PASS' if dsrD >= 0.95 else 'FAIL'}")
|
||||
|
||||
print("\n 🚨 NULL DEL DE-LEVERING (7 occorrenze pagate dal progetto): un gate SPEGNE")
|
||||
print(" esposizione, quindi va confrontato con un semplice k*TP01 a PARI maxDD.")
|
||||
tgt_dd = chosenD["dd"]
|
||||
lo, hi = 0.05, 1.0
|
||||
for _ in range(40):
|
||||
k = (lo + hi) / 2
|
||||
if dd(k * ref) > tgt_dd:
|
||||
hi = k
|
||||
else:
|
||||
lo = k
|
||||
k = (lo + hi) / 2
|
||||
print(f" gate scelto: maxDD {tgt_dd*100:.2f}% ShFULL {chosenD['full']:+.3f} "
|
||||
f"ShHOLD {chosenD['hold']:+.3f}")
|
||||
print(f" k*TP01 a pari maxDD (k={k:.3f}): maxDD {dd(k*ref)*100:.2f}% "
|
||||
f"ShFULL {sh(k*ref):+.3f} ShHOLD {sh((k*ref)[(k*ref).index>=HOLDOUT]):+.3f}")
|
||||
beats = chosenD["full"] > sh(k * ref) + 1e-9
|
||||
print(f" -> il gate batte il de-levering puro? {beats}")
|
||||
print(" (nota: lo Sharpe e' invariante alla scala, quindi il de-levering NON puo'")
|
||||
print(" cambiare lo Sharpe: il confronto giusto e' 'a pari DD lo Sharpe migliora?'")
|
||||
print(" -> qui la domanda si riduce a dShFULL > 0, e il null e' DEGENERE (§24 (d)).")
|
||||
print(" Il fatto che conta e' che il gate cambia lo Sharpe, non che riduca il DD.")
|
||||
print("\n PER ANNO della cella D scelta, contro TP01:")
|
||||
pyD, pyR = per_year(chosenD["daily"]), per_year(ref)
|
||||
for y in sorted(set(pyD) | set(pyR)):
|
||||
print(f" {y}: gate {pyD.get(y, float('nan')):+6.2f} TP01 {pyR.get(y, float('nan')):+6.2f}"
|
||||
f" d {pyD.get(y,np.nan)-pyR.get(y,np.nan):+6.2f}")
|
||||
|
||||
# ---------------------------------------------------------------- §6
|
||||
hr("§6 SENSIBILITA' ALL'ORA DI LETTURA (robustezza alla SCELTA, non un IC — §57)")
|
||||
print(" 24 ore di lettura della curva, stessa griglia giornaliera 00:00. Tutte causali.")
|
||||
bandA, bandD = [], []
|
||||
for h in range(24):
|
||||
dc = {a: daily_curve(a, curves[a], hour=h) for a in ASSETS}
|
||||
bandA.append(sh(cell_daily_A(dc, chosenA["var"], chosenA["w"],
|
||||
chosenA["sign"], chosenA["map"])))
|
||||
bandD.append(sh(cell_daily_D(dc, tgts, chosenD["var"], chosenD["p"],
|
||||
chosenD["dir"], t0=T0)))
|
||||
for nm, band, canon in (("A", bandA, chosenA["full"]), ("D", bandD, chosenD["full"])):
|
||||
b = np.array(band)
|
||||
print(f" ramo {nm}: canonica(h={SIG_HOUR}) {canon:+.3f} mediana {np.median(b):+.3f}"
|
||||
f" p10 {np.percentile(b,10):+.3f} p90 {np.percentile(b,90):+.3f}"
|
||||
f" pctl della canonica {float((b<=canon).mean())*100:.0f}°")
|
||||
bD = np.array(bandD) - sh(ref)
|
||||
print(f" ramo D, dShFULL vs TP01 su 24 ore: mediana {np.median(bD):+.3f}, "
|
||||
f"positivo in {int((bD>0).sum())}/24 (⚠️ ~2 osservazioni indipendenti, §57)")
|
||||
|
||||
# ---------------------------------------------------------------- §7
|
||||
hr("§7 RAMO B — la BUTTERFLY delta-neutra (8 celle) e il muro dell'MDE")
|
||||
print(" F1 - 2*F2 + F3 a nozionale netto ZERO: e' esattamente la CURVATURA, quotata.")
|
||||
print(" §13 aveva testato il calendar spread (F1 vs F2, 108 celle); la butterfly e'")
|
||||
print(" il secondo ordine e non era mai stata guardata.\n")
|
||||
fly = {}
|
||||
for a in ASSETS:
|
||||
C = curves[a]
|
||||
closes, exps, _ = load_contracts(a)
|
||||
wide = pd.DataFrame(closes).sort_index().reindex(C.index)
|
||||
DTEa = pd.DataFrame({nm: (exps[nm] - wide.index).total_seconds() / 86400.0
|
||||
for nm in wide.columns}, index=wide.index).where(wide.notna())
|
||||
lr = np.log(wide).diff()
|
||||
dv, lv = DTEa.values, lr.values
|
||||
pv = wide.values
|
||||
n = len(wide)
|
||||
out = np.full(n, np.nan)
|
||||
turn = np.zeros(n)
|
||||
prev = None
|
||||
for i in range(n):
|
||||
m = np.isfinite(dv[i]) & np.isfinite(pv[i]) & (dv[i] > 0.5)
|
||||
ordr = np.argsort(np.where(m, dv[i], np.inf))
|
||||
sel = ordr[:3]
|
||||
if not np.all(m[sel]) or len(sel) < 3:
|
||||
prev = None
|
||||
continue
|
||||
wts = np.array([1.0, -2.0, 1.0])
|
||||
if prev is not None and np.array_equal(prev, sel):
|
||||
r = np.nansum(wts * lv[i][sel])
|
||||
out[i] = r
|
||||
else:
|
||||
turn[i] = 4.0 # 4 gambe di nozionale unitario cambiate (1+2+1)
|
||||
prev = sel
|
||||
fly[a] = pd.Series(out, index=wide.index), pd.Series(turn, index=wide.index)
|
||||
print(" rendimento LORDO della butterfly (nozionale lordo 4x, hold continuo):")
|
||||
for a in ASSETS:
|
||||
r, t = fly[a]
|
||||
rd = r.resample("1D").sum().dropna()
|
||||
yrs = (rd.index[-1] - rd.index[0]).days / YR
|
||||
mu = float(rd.mean() * YR)
|
||||
sd = float(rd.std() * np.sqrt(YR))
|
||||
se = sd / np.sqrt(yrs)
|
||||
n_roll = int((t > 0).sum())
|
||||
print(f" {a}: drift {mu*100:+6.2f}%/anno vol {sd*100:5.2f}% Sharpe {mu/sd:+.2f}"
|
||||
f" SE(drift) {se*100:.2f}pp roll {n_roll} in {yrs:.1f} anni")
|
||||
print(f" 🚨 MDE: serve |drift| > {1.96*se*100:.2f}%/anno per distinguerlo da zero.")
|
||||
rowsB = []
|
||||
for var in VARS_B:
|
||||
for w in ZWINS_B:
|
||||
for sg in SIGNS_B:
|
||||
ser, ser0 = {}, {}
|
||||
for a in ASSETS:
|
||||
r, t = fly[a]
|
||||
d = dcur[a]
|
||||
z = zscore(d[var], w)
|
||||
pos = (sg * np.clip(z / 2, -1, 1)).fillna(0.0)
|
||||
rd = r.resample("1D").sum()
|
||||
td = t.resample("1D").sum()
|
||||
idx = rd.index.intersection(pos.index)
|
||||
p = pos.reindex(idx).shift(1).fillna(0.0)
|
||||
gross = p * rd.reindex(idx)
|
||||
cost = (p.abs() * td.reindex(idx).fillna(0.0) +
|
||||
4.0 * p.diff().abs().fillna(0.0))
|
||||
ser[a] = gross - FEE_SIDE * cost
|
||||
ser0[a] = gross
|
||||
J = pd.concat(ser, axis=1, join="inner").fillna(0.0)
|
||||
J0 = pd.concat(ser0, axis=1, join="inner").fillna(0.0)
|
||||
s = 0.5 * J[ASSETS[0]] + 0.5 * J[ASSETS[1]]
|
||||
s0 = 0.5 * J0[ASSETS[0]] + 0.5 * J0[ASSETS[1]]
|
||||
ins, hol = split(s)
|
||||
rowsB.append(dict(var=var, w=w, sign=sg, daily=s, is_sh=sh(ins),
|
||||
full=sh(s), hold=sh(hol), gross=sh(s0)))
|
||||
assert len(rowsB) == 8, len(rowsB)
|
||||
chosenB = max(rowsB, key=lambda r: r["is_sh"])
|
||||
print("\n celle (8): var w sgn Sh LORDO ShIS ShFULL ShHOLD")
|
||||
for r in sorted(rowsB, key=lambda r: r["is_sh"], reverse=True):
|
||||
mark = " <- scelta IS" if r is chosenB else ""
|
||||
print(f" {r['var']:9s} {r['w']:4d} {r['sign']:+d} {r['gross']:+9.3f}"
|
||||
f" {r['is_sh']:+7.3f} {r['full']:+8.3f} {r['hold']:+7.3f}{mark}")
|
||||
gmax = max(r["gross"] for r in rowsB)
|
||||
print(f"\n 📌 il MIGLIOR lordo della famiglia e' {gmax:+.3f}: sotto l'MDE (Sharpe 0,72)")
|
||||
print(" ANCHE a fee zero. Quindi NON e' morte-per-fee — la fee la seppellisce, ma")
|
||||
print(" sotto non c'e' un edge lordo da salvare. (Distinzione che il progetto fa")
|
||||
print(" sistematicamente: §42 TP01-LS, §7 CRT.)")
|
||||
|
||||
# ---------------------------------------------------------------- §8
|
||||
hr("§8 RAMO C — la curva predice la VOLATILITA' futura? (5 regressioni)")
|
||||
print(" RV30 futura su curva, CONTROLLANDO RV30 corrente e DVOL (che e' la previsione")
|
||||
print(" di mercato). Senza i controlli si misura solo 'la vol e' persistente'.\n")
|
||||
for a in ASSETS:
|
||||
d = dcur[a]
|
||||
lp = np.log(d["S"])
|
||||
r = lp.diff()
|
||||
rv = r.rolling(30).std() * np.sqrt(YR)
|
||||
fut = rv.shift(-30)
|
||||
ts = pd.DataFrame({"timestamp": _ms(d.index)})
|
||||
dv = pd.Series(al.dvol(ts, a), index=d.index) / 100.0
|
||||
assert dv.notna().sum() > 500 and 0.2 < float(dv.median()) < 1.5, (
|
||||
"controllo positivo DVOL fallito: merge vuoto o fuori scala "
|
||||
f"(n={int(dv.notna().sum())}, mediana={float(dv.median()):.3f})")
|
||||
base = pd.concat({"y": fut, "rv": rv, "dv": dv}, axis=1).dropna()
|
||||
print(f" --- {a} (n={len(base):,}, dal {base.index.min().date()}: DVOL parte 2021-03) ---")
|
||||
for v in VARS_A:
|
||||
jj = pd.concat([base, d[v].rename("x")], axis=1).dropna()
|
||||
if len(jj) < 200:
|
||||
print(f" {v:9s} n troppo piccolo")
|
||||
continue
|
||||
X = np.column_stack([np.ones(len(jj)), jj["rv"], jj["dv"],
|
||||
(jj["x"] - jj["x"].mean()) / jj["x"].std()])
|
||||
bb, *_ = np.linalg.lstsq(X, jj["y"].values, rcond=None)
|
||||
res = jj["y"].values - X @ bb
|
||||
s2 = res @ res / (len(jj) - 4)
|
||||
se = np.sqrt(np.diag(s2 * np.linalg.pinv(X.T @ X)))[3]
|
||||
print(f" {v:9s} beta {bb[3]*100:+6.2f}pp di vol per 1sd "
|
||||
f"t {bb[3]/se:+6.2f} (naive) t/sqrt(30) {bb[3]/se/np.sqrt(30):+5.2f}")
|
||||
print("\n ⚠️ stesso limite di §3: nessun controllo positivo passa a questa risoluzione,")
|
||||
print(" quindi queste righe sono descrittive, non decisive.")
|
||||
|
||||
# ---------------------------------------------------------------- §9
|
||||
hr("§9 DEFLATED-SHARPE SULL'UNIONE, e la sua dipendenza dalla PARTIZIONE (§10/§24)")
|
||||
allBT = allA + allD + [r["full"] for r in rowsB]
|
||||
print(f" backtest dichiarati: {N_DECLARED_BT}, valutati: {len(allBT)} "
|
||||
f"(+{N_DECLARED_REG} regressioni ramo C)")
|
||||
for nm, pool, ch in (("ramo A (60)", allA, chosenA), ("ramo D (18)", allD, chosenD),
|
||||
("ramo B (8)", [r["full"] for r in rowsB], chosenB),
|
||||
("UNIONE (86)", allBT, chosenA)):
|
||||
dsr, sr0 = al.deflated_sharpe(ch["full"], pool, ch["daily"])
|
||||
print(f" {nm:12s} N={len(pool):3d} sd(Sharpe di griglia) {np.std(pool, ddof=1):.3f}"
|
||||
f" max atteso dal rumore {sr0:+.3f} DSR {dsr:.3f} "
|
||||
f"{'PASS' if dsr >= 0.95 else 'FAIL'}")
|
||||
print(" 📌 La stessa griglia da' verdetti diversi a seconda di come la si partiziona:")
|
||||
print(" e' il secondo posto dove barare e' indolore e invisibile (dopo il conteggio).")
|
||||
|
||||
# ---------------------------------------------------------------- §10
|
||||
hr("§10 ESEGUIBILITA' — il roll trimestrale, e il muro che nessun backtest supera")
|
||||
lb = Path("/tmp/claude-1001/-opt-docker-PythagorasGoal/"
|
||||
"b6cc75e7-14f8-4c32-bd07-ab8a0d2aaee6/scratchpad/basis_cache/live_books.parquet")
|
||||
if lb.exists():
|
||||
d = pd.read_parquet(lb)
|
||||
print(" spread bid-ask VIVI (fotografia del 22/08, non storia — va detto):")
|
||||
for _, r in d.iterrows():
|
||||
print(f" {r['instrument']:16s} spread {r['spread_bps']:6.2f} bps"
|
||||
f" mezzo-spread {r['spread_bps']/2:5.2f} bps")
|
||||
q = d[d.instrument.str.contains("-2")]
|
||||
hs = float(q["spread_bps"].median()) / 2
|
||||
else:
|
||||
hs = 3.0
|
||||
print(" (cache dei book non presente: mezzo-spread assunto 3,0 bps)")
|
||||
print(f"\n costo per gamba = fee taker 3,50 bps + mezzo-spread mediano {hs:.2f} bps"
|
||||
f" = {3.5+hs:.2f} bps")
|
||||
print(f" un ROLL trimestrale = 2 gambe (chiudi F1, apri F2) = {2*(3.5+hs):.1f} bps,")
|
||||
print(f" 4 roll/anno = {4*2*(3.5+hs):.0f} bps/anno = {4*2*(3.5+hs)/100:.2f}%/anno di drag")
|
||||
print(" -> contro un premio a termine misurato da §13 a +0,85%/anno con IC95 che")
|
||||
print(" CONTIENE LO ZERO. Il costo del roll da solo e' dello stesso ordine.")
|
||||
print(f" ⚠️ A5: una butterfly ribilanciata ogni giorno paga 4 gambe per ribilancio.")
|
||||
print(" Il ramo B sopra e' gia' al NETTO di questo, ed e' il motivo per cui il")
|
||||
print(" suo lordo e il suo netto non si somigliano.")
|
||||
|
||||
# ---------------------------------------------------------------- §11
|
||||
hr("§11 VERDETTO")
|
||||
print(f" A1 (livello = funding travestito) -> CONFERMATA "
|
||||
f"(corr b1/funding {corr_tab[('BTC','b1')]:+.2f} BTC, {corr_tab[('ETH','b1')]:+.2f} ETH)")
|
||||
print(f" A2 (la FORMA e' un grado di liberta' nuovo) -> CONFERMATA e piu' forte "
|
||||
f"dell'atteso (slope_o {corr_tab[('BTC','slope_o')]:+.2f}/"
|
||||
f"{corr_tab[('ETH','slope_o')]:+.2f}, curv {corr_tab[('BTC','curv')]:+.2f}/"
|
||||
f"{corr_tab[('ETH','curv')]:+.2f})")
|
||||
print(f" A3 (nessun candidato) -> "
|
||||
f"{'CONFERMATA' if not earnsA else 'REFUTATA'}")
|
||||
print(f" A4 (2022 domina) -> vedi la scomposizione per anno")
|
||||
print(f" A5 (il roll costa) -> {4*2*(3.5+hs)/100:.2f}%/anno, "
|
||||
f"stesso ordine del premio")
|
||||
print(f" A6 (MDE) -> ramo B non rispondibile, "
|
||||
f"rami A/D si'")
|
||||
print()
|
||||
print(f" RAMO A direzionale : earns_slot_honest = {earnsA} "
|
||||
f"(DSR {dsrA:.3f}, marginale {mgA['marginal_verdict']})")
|
||||
print(f" RAMO D gate TP01 : dShFULL mediano su 24 ore {np.median(bD):+.3f}, "
|
||||
f"DSR {dsrD:.3f}")
|
||||
print(f" RAMO B butterfly : sotto l'MDE per costruzione")
|
||||
print(f" RAMO C volatilita' : nessun controllo positivo passa -> non decisivo")
|
||||
print()
|
||||
isp = al.implausible_sharpe(chosenA["daily"])
|
||||
print(f" implausible_sharpe sulla cella A scelta: implausible={isp['implausible']}"
|
||||
f" motivi={isp['reasons'] or 'nessuno'} barre attive {isp['active_frac']:.0%}"
|
||||
f" barre attive in perdita {isp['loss_frac']:.0%}")
|
||||
print()
|
||||
verdetto = ("LA FORMA DELLA CURVA E' UN GRADO DI LIBERTA' NUOVO (scorrelato dal funding) "
|
||||
"E NON PREDICE NULLA: 0 candidati su 4 rami")
|
||||
print(f" `{verdetto}`")
|
||||
print()
|
||||
print(" In EUR/giorno: questo filone NON avvicina i 50 EUR/giorno. Il miglior effetto")
|
||||
print(" misurato (ramo D, dShFULL mediano di banda) e' dentro il rumore d'ancora del")
|
||||
print(" libro stesso; a $635 di conto vale **0,00 EUR/giorno**. Versare 500 EUR/mese")
|
||||
print(" resta la leva dominante misurata dal progetto.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,890 @@
|
||||
"""r0823b_fisco_payout — §63 FISCO-PAYOUT: l'aliquota sui payout funded e' un FORFAIT mai
|
||||
giustificato, e il canale funded non e' mai stato misurato contro di essa (2026-08-23).
|
||||
|
||||
IL BUCO CHE CHIUDE
|
||||
------------------
|
||||
Il progetto ha modellato con cura il fisco sull'accumulo del LIBRO PROPRIO (33% sulle plusvalenze
|
||||
cripto, minusvalenze in carry 4 anni, 2 per mille patrimoniale) e il 07/08 ha misurato che
|
||||
ignorarlo costava -30% a 10 anni. Sul canale FUNDED non ha modellato niente: `r0725_prop_ladder.py`
|
||||
importa `TAX_RATE = 0.33` da `r0725_capcurve` e lo applica ai payout con una riga
|
||||
|
||||
net = gross * (1.0 - TAX_RATE) # r0725_prop_ladder:269
|
||||
|
||||
senza una giustificazione. Ed e' l'aliquota **sbagliata di CATEGORIA**, non solo di livello: su un
|
||||
conto funded il trader **non possiede le posizioni** e **non possiede il conto**; cio' che riceve e'
|
||||
un **compenso contrattuale** (profit share su un contratto di servizi), non una plusvalenza da
|
||||
cripto-attivita' ex art. 67 c.1 lett. c-sexies TUIR. Il 33% e' l'aliquota di una cosa che qui non
|
||||
succede.
|
||||
|
||||
Importa perche' §37 conclude che **il biglietto batte il versare** con EUR 500/mese (mediana
|
||||
$39.820 contro $22.444). Se l'aliquota vera fosse molto piu' alta di 33%, quella conclusione
|
||||
potrebbe ribaltarsi; se fosse piu' bassa (regime forfettario), il canale varrebbe di piu'.
|
||||
|
||||
QUESTO FILONE NON CONCLUDE QUALE SIA L'ALIQUOTA. Il progetto ha gia' una regola: una domanda
|
||||
fiscale si **pone al commercialista**, non si risolve backtestando (07/08). Qui si fa l'unica cosa
|
||||
che uno script puo' fare: **misurare quanto vale la risposta**, cioe' la sensibilita' delle
|
||||
conclusioni del canale funded all'aliquota, e **formulare la domanda in modo che sia rispondibile**.
|
||||
NON e' un parere fiscale.
|
||||
|
||||
LE ATTESE, REGISTRATE PRIMA DI MISURARE
|
||||
---------------------------------------
|
||||
A1. **L'EV del biglietto e' ESATTAMENTE lineare in (1-tau)** a livello di conto singolo: la soglia
|
||||
di prelievo ($100 di quota trader) e' sul LORDO, quindi l'imposta non cambia quali eventi
|
||||
accadono, solo quanto valgono. Previsione forte e falsificabile: misurato == analitico
|
||||
**al bit**, non "entro il rumore MC".
|
||||
A2. **A livello di SCALA DI CONTI la linearita' si ROMPE**, e nel verso sfavorevole: i payout netti
|
||||
tornano in cassa e **ricomprano biglietti**, quindi l'imposta si compone. Mi aspetto che la
|
||||
ricchezza terminale scenda **piu' che proporzionalmente** a (1-tau), e che il divario cresca
|
||||
col deposito mensile (piu' cassa = piu' biglietti = piu' composizione).
|
||||
A3. **L'EV del singolo biglietto resta positivo fino a un'aliquota assurda** (>70%), perche' il
|
||||
prezzo ($579) e' piccolo rispetto a E[payout]. Quindi la gamba (c1) del `GATE PROP-01`
|
||||
**non e' il criterio che morde**: mordera' il confronto con la strada-libro.
|
||||
A4. **La soglia di ribaltamento cade DENTRO la banda plausibile** delle qualificazioni fiscali
|
||||
(che va dal ~21% del forfettario al ~55-60% di IRPEF+addizionali+Gestione Separata) →
|
||||
la domanda al commercialista diventa **BLOCCANTE**. Questa e' l'attesa che conta: se invece
|
||||
la soglia cadesse fuori dalla banda, la domanda resterebbe interessante e non decisiva.
|
||||
A5. **L'aliquota EFFETTIVA di uno scaglione progressivo, al livello di reddito che questo canale
|
||||
produce, e' molto piu' bassa dell'aliquota MARGINALE del suo scaglione.** EUR 50/giorno sono
|
||||
~EUR 18.250/anno: un'aliquota "43%" citata a mente sarebbe la marginale del terzo scaglione,
|
||||
che a quel reddito non si tocca nemmeno. Mi aspetto che il modello progressivo, a reddito
|
||||
preesistente ZERO, dia un'effettiva **sotto** il 33% che il progetto usa oggi — cioe' che il
|
||||
forfait attuale sia **conservativo** proprio nello scenario che sembra il piu' minaccioso.
|
||||
Ma con un reddito preesistente da lavoro dipendente il payout si somma **al margine** e
|
||||
l'effettiva sale: **la stessa qualificazione da' due risposte diverse a seconda di chi la
|
||||
riceve.** Questo, se confermato, e' il risultato trasferibile del filone.
|
||||
|
||||
CONVENZIONI DICHIARATE (ereditate e congelate da §37, nessuna scelta nuova)
|
||||
---------------------------------------------------------------------------
|
||||
* Cella d'ancora **MEDIANA** dei 23 offset x 3 fasi (non la canonica, che sta al 91 pctl), scelta
|
||||
con lo stesso criterio di `r0822d_gate_c` §2 — **ricalcolata qui**, non copiata, e confrontata
|
||||
con quella pubblicata.
|
||||
* Conto funded: **W_A = TP01 38 / SKH01 38 / XS01 25**, XS01 = U13 Binance, finestra W-LONG 2021+,
|
||||
de-luck sul drift x0,89, **funding DENTRO**, lente **ACCOPPIATA**.
|
||||
* Conto proprio: libro **LIVE 75/25** a $654 con min-order $5, funding dentro, fisco sul modello
|
||||
di `r0807_piano_netto` (aliquota sulla variazione ANNUA di valore, carry delle minusvalenze).
|
||||
* Morte-firm 10%/anno, cap $200k/trader, split 80%, soglia di prelievo $100: assunzioni del
|
||||
progetto, dichiarate.
|
||||
* Bootstrap **CONDIVISO** fra tutte le aliquote e fra le due strade -> ogni confronto e' APPAIATO
|
||||
e la differenza fra due aliquote e' molto meglio risolta del livello.
|
||||
|
||||
Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_fisco_payout.py`
|
||||
Rete: NESSUNA. Scritture: NESSUNA.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
T0 = time.time()
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
if "--no-net" not in sys.argv:
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm
|
||||
import r0822_prop_alloc as PA # noqa: E402 boot_idx, DELUCK
|
||||
import r0822b_prop_recal as PR # noqa: E402 pannelli, obj_rg
|
||||
import r0822b_xs01_oos as X # noqa: E402 U13
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01
|
||||
import r0822d_funding as FD # noqa: E402 funding
|
||||
import r0822d_gate_c as GC # noqa: E402 LA MACCHINERIA DI §37
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
EURUSD = pl.EURUSD
|
||||
SPLIT = pl.SPLIT
|
||||
DELUCK = PA.DELUCK
|
||||
W_A = GC.W_A
|
||||
W_LIVE = GC.W_LIVE
|
||||
OFFSETS = AP.OFFSETS
|
||||
PHASES_SUB = AP.PHASES_SUB
|
||||
N_LAD = GC.N_PATHS_LAD
|
||||
N_TIX = GC.N_PATHS_TIX
|
||||
SEED_LAD = GC.SEED_LAD
|
||||
MIN_PAYOUT = GC.MIN_PAYOUT_TRADER
|
||||
HORIZON_DAYS = GC.HORIZON_DAYS
|
||||
PRICE_100K = 579.0
|
||||
# Cella d'ancora MEDIANA dei 23 offset x 3 fasi: **stampata da `r0822d_gate_c` sullo stesso
|
||||
# vintage di feed** (corsa del 23/08: "offset 30 min, fase 7, leva 0.75x"). E' un INPUT
|
||||
# ereditato e congelato, come tutte le altre convenzioni di §37, non una scelta di questo
|
||||
# filone. Ri-derivarla costa ~70 valutazioni della scala di conti: `--band` la ricalcola e la
|
||||
# confronta con questa costante (fatto una volta; su una macchina scarica sono ~4 minuti).
|
||||
CELL_M = (30, 7, 0.75)
|
||||
BAND = "--band" in sys.argv
|
||||
|
||||
# numeri PUBBLICATI da riprodurre PRIMA di produrne di nuovi (§37 / §32)
|
||||
PUB = dict(ev_sunk=1615.0, ev_at_pass=1919.0, ev_at_payout=1835.0,
|
||||
p50g_fund=0.026, pzero_fund=0.403,
|
||||
med_big_500=39820.0, med_lib_500=22444.0,
|
||||
med_big_0=132.0, med_lib_0=787.0,
|
||||
mean_big_500=46298.0, mean_lib_500=22694.0,
|
||||
mean_big_0=9592.0, mean_lib_0=803.0)
|
||||
|
||||
|
||||
# =============================================================================== 0. IL FISCO
|
||||
# ATTENZIONE — QUESTA SEZIONE NON E' UN PARERE FISCALE.
|
||||
# Ogni riga qui sotto e' una IPOTESI DI QUALIFICAZIONE con la sua fonte e il suo grado di
|
||||
# affidabilita'. Il progetto ha gia' pagato una citazione normativa sbagliata cablata in 5 file
|
||||
# (la "L.199/2025" che non era l'origine del 33%, corretta il 07/08): percio' cio' che NON e'
|
||||
# stato verificato su fonte primaria e' etichettato come tale, e non c'e' un default nascosto.
|
||||
#
|
||||
# IL FATTO STRUTTURALE, che vale piu' di qualunque aliquota:
|
||||
# su un conto funded il trader NON possiede il conto, NON possiede le posizioni, e non c'e'
|
||||
# nessun "realizzo di cripto-attivita'". Riceve una quota di un risultato SIMULATO in base a un
|
||||
# contratto. Percio' l'art. 67 c.1 lett. c-sexies (33%, cripto) e la lett. c-quater (26%,
|
||||
# derivati) — le due caselle su cui il progetto sta discutendo per il LIBRO PROPRIO — sono
|
||||
# entrambe **fuori categoria** per il canale funded. La discussione vera e' fra reddito
|
||||
# diverso da "obbligazione di fare" (art. 67 c.1 lett. l), lavoro autonomo (abituale o
|
||||
# occasionale) e reddito d'impresa. Cambia la CATEGORIA, non solo il numero.
|
||||
|
||||
# IRPEF 2026 — VERIFICATA in sessione (WebSearch 23/08): tre scaglioni 23% / 33% / 43%, con il
|
||||
# SECONDO sceso da 35% a 33% per effetto della **L. 199/2025** (Legge di Bilancio 2026).
|
||||
# ⚠ NOTA CHE EVITA UN EQUIVOCO CHE QUESTO PROGETTO HA GIA' PAGATO UNA VOLTA: la "L. 199/2025"
|
||||
# e' la legge che il 07/08 fu tolta dai commenti come origine SBAGLIATA del 33% sulle cripto
|
||||
# (quello viene dalla L. 207/2024 art. 1 c. 23-29). Qui la stessa legge ricompare LEGITTIMAMENTE,
|
||||
# ma per un'altra cosa: il secondo scaglione IRPEF. **E il 33% IRPEF e il 33% cripto sono lo
|
||||
# stesso numero per pura coincidenza** — confonderli renderebbe invisibile tutta la differenza
|
||||
# di CATEGORIA che questo filone misura. Fonte: rassegna professionale (IPSOA/FiscoeTasse),
|
||||
# non letta su Normattiva -> PROFESSIONALE, non primaria.
|
||||
IRPEF_SCAGLIONI = ((28_000.0, 0.23), (50_000.0, 0.33), (float("inf"), 0.43))
|
||||
IRPEF_2025 = ((28_000.0, 0.23), (50_000.0, 0.35), (float("inf"), 0.43)) # controllo di robustezza
|
||||
ADDIZIONALI = 0.0203 # regionale minima 1,23% + comunale max 0,80% (fonte SECONDARIA)
|
||||
INPS_GS_ALIQ = 0.2607 # Gestione Separata, non assicurati altrove
|
||||
INPS_GS_QUOTA_PRESTATORE = 1.0 / 3.0
|
||||
INPS_OCC_FRANCHIGIA = 5_000.0
|
||||
FORFETTARIO_COEFF = 0.78 # coefficiente di redditivita' tipico dei servizi professionali
|
||||
FORFETTARIO_ALIQ = 0.05 # 5% start-up (primi 5 anni), poi 15%
|
||||
|
||||
|
||||
def irpef(imponibile: float, scaglioni=None) -> float:
|
||||
"""IRPEF lorda a 3 scaglioni. Nessuna detrazione (conservativo: le detrazioni la abbassano)."""
|
||||
t, prev = 0.0, 0.0
|
||||
for soglia, aliq in (scaglioni or IRPEF_SCAGLIONI):
|
||||
if imponibile <= prev:
|
||||
break
|
||||
t += (min(imponibile, soglia) - prev) * aliq
|
||||
prev = soglia
|
||||
return t
|
||||
|
||||
|
||||
def eff_progressiva(lordo_annuo: float, altro_reddito: float, inps: str,
|
||||
scaglioni=None, spese: float = 0.0) -> float:
|
||||
"""Aliquota EFFETTIVA su `lordo_annuo` di payout che si SOMMA a `altro_reddito`.
|
||||
`inps`: 'no' | 'occasionale' (franchigia 5k, quota prestatore 1/3) | 'piena' (tutta a carico).
|
||||
Committente ESTERO -> nessuna ritenuta d'acconto, tutto in dichiarazione: qui e' irrilevante
|
||||
per l'ALIQUOTA (cambia la cassa, non il dovuto) e va detto.
|
||||
Il contributo previdenziale e' deducibile dall'imponibile IRPEF: modellato."""
|
||||
if lordo_annuo <= 0:
|
||||
return 0.0
|
||||
# art. 71 c.2 TUIR (verificato sul testo, 23/08): i redditi di cui all'art. 67 c.1 lett. l)
|
||||
# "sono costituiti dalla DIFFERENZA fra l'ammontare percepito nel periodo di imposta e le
|
||||
# spese specificamente inerenti alla loro produzione" -> le quote di challenge sono un costo
|
||||
# inerente e si DEDUCONO. Sotto un'imposta sostitutiva su reddito finanziario, no.
|
||||
netto = max(0.0, lordo_annuo - spese)
|
||||
if inps == "no":
|
||||
contrib = 0.0
|
||||
elif inps == "occasionale":
|
||||
base = max(0.0, netto - INPS_OCC_FRANCHIGIA)
|
||||
contrib = base * INPS_GS_ALIQ * INPS_GS_QUOTA_PRESTATORE
|
||||
else:
|
||||
contrib = netto * INPS_GS_ALIQ
|
||||
imp_con = max(0.0, altro_reddito + netto - contrib)
|
||||
imp_senza = max(0.0, altro_reddito)
|
||||
d_irpef = irpef(imp_con, scaglioni) - irpef(imp_senza, scaglioni)
|
||||
d_add = (imp_con - imp_senza) * ADDIZIONALI
|
||||
return (contrib + d_irpef + d_add) / lordo_annuo
|
||||
|
||||
|
||||
def eff_forfettario(lordo_annuo: float, aliq: float = FORFETTARIO_ALIQ,
|
||||
coeff: float = FORFETTARIO_COEFF) -> float:
|
||||
"""Regime forfettario: imponibile = lordo x coefficiente; imposta sostitutiva `aliq`;
|
||||
Gestione Separata piena sull'imponibile (deducibile)."""
|
||||
if lordo_annuo <= 0:
|
||||
return 0.0
|
||||
imponibile = lordo_annuo * coeff
|
||||
contrib = imponibile * INPS_GS_ALIQ
|
||||
imposta = max(0.0, imponibile - contrib) * aliq
|
||||
return (contrib + imposta) / lordo_annuo
|
||||
|
||||
|
||||
# ==================================================== 1. LA SCALA DI CONTI CON L'IMPOSTA APERTA
|
||||
|
||||
def ladder_tax(R: np.ndarray, G: np.ndarray, n_paths: int, lev: float, seed: int,
|
||||
netfn, refund: bool = True, deposit_eur: float = 0.0,
|
||||
start_eur: float = pl.START_EUR, min_payout: float = MIN_PAYOUT,
|
||||
boot: np.ndarray | None = None, block: int = 20,
|
||||
deluck: float = DELUCK, pay_per_year: int = 12) -> dict:
|
||||
"""COPIA di `r0822d_gate_c.ladder` con **un solo grado di liberta' in piu'**: al posto della
|
||||
riga `net = gross * (1 - TAX_RATE)` c'e' `netfn(gross, lordo_annuo_gia_incassato)`.
|
||||
Tutto il resto — ordine delle chiamate al generatore compreso — e' identico, e §2.1 lo
|
||||
verifica **bit-exact** contro l'originale con `netfn` piatta al 33%.
|
||||
|
||||
`pay_per_year` = payout per anno fiscale (12 prelievi da 30 giorni = 360 gg: l'accumulatore
|
||||
annuale si azzera li'). Serve solo alle aliquote PROGRESSIVE, che dipendono dal lordo annuo.
|
||||
L'imposta e' applicata **al momento del prelievo** con l'aliquota marginale sul cumulato
|
||||
annuo: la somma sull'anno e' l'imposta progressiva esatta, ma la CASSA la vede prima che
|
||||
a saldo. Differenza dichiarata, e conservativa (toglie liquidita' prima)."""
|
||||
rng = np.random.default_rng(seed)
|
||||
n_days = HORIZON_DAYS
|
||||
L = len(R)
|
||||
Rm = R.astype(float).reshape(-1, 1).copy()
|
||||
Gm = G.astype(float).reshape(-1, 1).copy()
|
||||
Rm = Rm - (1.0 - deluck) * Rm.mean(axis=0, keepdims=True)
|
||||
if boot is None:
|
||||
n_blocks = int(np.ceil(n_days / block))
|
||||
starts = rng.integers(0, L - block, size=(n_paths, n_blocks))
|
||||
idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days]
|
||||
else:
|
||||
idx = boot
|
||||
n_slot = pl.MAX_CONCURRENT
|
||||
sel = np.zeros(n_slot, dtype=int)
|
||||
Rs = Rm[idx][:, :, sel] * lev
|
||||
G_ = Gm[idx][:, :, sel] * lev
|
||||
|
||||
FIRMS = pl.FIRMS
|
||||
cash = np.full(n_paths, start_eur * EURUSD)
|
||||
phase = np.full((n_paths, n_slot), -1, np.int8)
|
||||
eq = np.ones((n_paths, n_slot))
|
||||
firm = np.full((n_paths, n_slot), -1, np.int8)
|
||||
notional = np.zeros((n_paths, n_slot))
|
||||
price_paid = np.zeros((n_paths, n_slot))
|
||||
refunded = np.zeros((n_paths, n_slot), bool)
|
||||
firm_alive = np.ones((n_paths, len(FIRMS)), bool)
|
||||
cum_payout = np.zeros(n_paths)
|
||||
cum_gross = np.zeros(n_paths)
|
||||
ann_gross = np.zeros(n_paths)
|
||||
spent_base = np.zeros(n_paths)
|
||||
spent = np.zeros(n_paths)
|
||||
got_back = np.zeros(n_paths)
|
||||
deposited = np.zeros(n_paths)
|
||||
n_payouts = np.zeros(n_paths, int)
|
||||
n_pay_events = 0
|
||||
p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0)
|
||||
|
||||
for t in range(n_days):
|
||||
died = rng.random((n_paths, len(FIRMS))) < p_death_day
|
||||
newly_dead = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly_dead.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly_dead[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm == fi) & kill[:, None]
|
||||
phase[hit] = -1
|
||||
notional[hit] = 0.0
|
||||
|
||||
for k in range(n_slot):
|
||||
free = phase[:, k] == -1
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
used = np.where(firm == fi, notional, 0.0).sum(axis=1)
|
||||
for (size, price) in sorted(F["tickets"], key=lambda x: -x[0]):
|
||||
buy = (free & firm_alive[:, fi] & (cash >= price)
|
||||
& (used + size <= F["cap"]))
|
||||
if not buy.any():
|
||||
continue
|
||||
cash[buy] -= price
|
||||
spent[buy] += price
|
||||
phase[buy, k] = 0
|
||||
eq[buy, k] = 1.0
|
||||
firm[buy, k] = fi
|
||||
notional[buy, k] = size
|
||||
price_paid[buy, k] = price
|
||||
refunded[buy, k] = False
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
r = Rs[:, t, :]
|
||||
g = G_[:, t, :]
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
|
||||
for fi, F in enumerate(FIRMS):
|
||||
s_ = act & (firm == fi)
|
||||
if not s_.any():
|
||||
continue
|
||||
ev_t, ev_dd, ev_dl = F["ev"]
|
||||
fu_ml, fu_dl = F["fu"]
|
||||
in_ev = s_ & (phase == 0)
|
||||
in_fu = s_ & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl)))
|
||||
| (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl))))
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + ev_t) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
|
||||
if (t + 1) % 30 == 0:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout)
|
||||
gain = np.where(pay, (eq - 1.0) * notional, 0.0)
|
||||
gross = gain.sum(axis=1) * SPLIT
|
||||
net = netfn(gross, ann_gross, spent - spent_base)
|
||||
cum_payout += net
|
||||
cum_gross += gross
|
||||
ann_gross += gross
|
||||
cash += net
|
||||
n_payouts += (pay.sum(axis=1) > 0).astype(int)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund:
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
if deposit_eur:
|
||||
cash += deposit_eur * EURUSD
|
||||
deposited += deposit_eur * EURUSD
|
||||
n_pay_events += 1
|
||||
if n_pay_events % pay_per_year == 0:
|
||||
ann_gross[:] = 0.0
|
||||
spent_base = spent.copy()
|
||||
|
||||
eur_day = cum_payout / EURUSD / (n_days / 365.0) / 365.0
|
||||
return dict(eur_day=eur_day, med=float(np.median(eur_day)),
|
||||
p_ge10=float((eur_day >= 10.0).mean()),
|
||||
p_target=float((eur_day >= pl.TARGET_EUR_DAY).mean()),
|
||||
p_zero=float((cum_payout <= 0).mean()),
|
||||
cash=cash, med_cash=float(np.median(cash)), mean_cash=float(cash.mean()),
|
||||
p10_cash=float(np.percentile(cash, 10)),
|
||||
p90_cash=float(np.percentile(cash, 90)),
|
||||
gross=float(cum_gross.mean()), net=float(cum_payout.mean()),
|
||||
spent=float(spent.mean()),
|
||||
excess=cash - (start_eur * EURUSD + deposited),
|
||||
mean_back=float(got_back.mean()), med_spent=float(np.median(spent)),
|
||||
contributed=float(start_eur * EURUSD + deposited.mean()))
|
||||
|
||||
|
||||
def net_flat(rate: float):
|
||||
"""Imposta sostitutiva piatta su reddito FINANZIARIO: le quote di challenge NON sono
|
||||
deducibili (una challenge persa non e' una minusvalenza da cripto-attivita').
|
||||
Espressione IDENTICA a quella di `GC.ladder` -> bit-exact."""
|
||||
def f(gross, ann, spese):
|
||||
return gross * (1.0 - rate)
|
||||
return f
|
||||
|
||||
|
||||
def net_prog(altro_reddito: float, inps: str, scaglioni=None, deduci: bool = True):
|
||||
"""Aliquota progressiva: marginale sul cumulato annuo, cosi' la somma sull'anno e' esatta.
|
||||
`deduci` = le quote di challigne dell'anno si sottraggono dalla base (art. 71 c.2 TUIR)."""
|
||||
def f(gross, ann, spese):
|
||||
out = np.zeros_like(gross)
|
||||
nz = gross > 0
|
||||
if nz.any():
|
||||
sp = np.asarray(spese, float) / EURUSD if deduci else np.zeros(len(gross))
|
||||
for i in np.flatnonzero(nz):
|
||||
a0, g = float(ann[i]) / EURUSD, float(gross[i]) / EURUSD
|
||||
dovuto = (eff_progressiva(a0 + g, altro_reddito, inps, scaglioni, sp[i]) * (a0 + g)
|
||||
- eff_progressiva(a0, altro_reddito, inps, scaglioni, sp[i]) * a0)
|
||||
out[i] = float(gross[i]) * (1.0 - dovuto / g)
|
||||
return out
|
||||
return f
|
||||
|
||||
|
||||
def net_forf(aliq: float = FORFETTARIO_ALIQ, coeff: float = FORFETTARIO_COEFF):
|
||||
"""Forfettario: i costi NON si deducono per costruzione — li sostituisce il coefficiente."""
|
||||
def f(gross, ann, spese):
|
||||
out = np.zeros_like(gross)
|
||||
nz = gross > 0
|
||||
if nz.any():
|
||||
for i in np.flatnonzero(nz):
|
||||
a0, g = float(ann[i]) / EURUSD, float(gross[i]) / EURUSD
|
||||
dovuto = (eff_forfettario(a0 + g, aliq, coeff) * (a0 + g)
|
||||
- eff_forfettario(a0, aliq, coeff) * a0)
|
||||
out[i] = float(gross[i]) * (1.0 - dovuto / g)
|
||||
return out
|
||||
return f
|
||||
|
||||
|
||||
# ================================================================= 2. IL PANNELLO E LA CELLA
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "-" * 104)
|
||||
if t:
|
||||
print(" " + t)
|
||||
print("-" * 104)
|
||||
|
||||
|
||||
def build(verbose: bool = True) -> dict:
|
||||
"""Ricostruisce ESATTAMENTE il contesto di `r0822d_gate_c` §0.2 + §2, cella d'ancora
|
||||
MEDIANA compresa. Non e' copiata dal diario: e' ricalcolata e poi confrontata."""
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13 = Ob.reindex(p13.index)[X.U13]
|
||||
h13 = Hb.reindex(p13.index)[X.U13]
|
||||
l13 = Lb.reindex(p13.index)[X.U13]
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES_SUB}
|
||||
xs0 = XSP[PHASES_SUB[0]]
|
||||
cry_idx = pc.crypto_daily_tuples(1.0, 0.0).index
|
||||
base = cry_idx.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
S_LONG = max(first13, pd.Timestamp("2021-01-01", tz="UTC"))
|
||||
I = base[base >= S_LONG]
|
||||
ev_b = PA.boot_idx(len(I), GC.EV_H, PA.N_PATHS, seed=GC.SEED_EV)
|
||||
fu_b = PA.boot_idx(len(I), GC.FU_H, PA.N_PATHS, seed=GC.SEED_FU)
|
||||
pc.DELUCK = DELUCK
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
raise SystemExit("cache funding assente: senza funding i numeri non sono quelli di §37")
|
||||
xs_ann = GC.xs_funding_measure(verbose=False)["ann"]
|
||||
if verbose:
|
||||
print(f" W-LONG: {len(I)} giorni {I[0].date()} -> {I[-1].date()} | de-luck x{DELUCK}")
|
||||
print(f" funding di XS01 misurato: {xs_ann*100:+.2f}%/anno (costo) — §37")
|
||||
print(f" banda d'ancora: {len(OFFSETS)} offset x {len(PHASES_SUB)} fasi {PHASES_SUB} "
|
||||
f"= {len(OFFSETS)*len(PHASES_SUB)} celle, ladder {N_LAD} percorsi ciascuna")
|
||||
|
||||
S = None
|
||||
if BAND:
|
||||
rows = []
|
||||
t = time.time()
|
||||
for off in OFFSETS:
|
||||
fA = GC.fvec_for(W_A, I, rate, off, xs_ann)
|
||||
for ph in PHASES_SUB:
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rx = R0 - fA
|
||||
j, lv, _ = GC.best_lev(Rx, G0, ev_b, fu_b)
|
||||
lad = GC.ladder(Rx, G0, N_LAD, lv, SEED_LAD, refund=False)
|
||||
rows.append(dict(off=off, ph=ph, J=j, lev=lv, p50=lad["p_target"],
|
||||
pz=lad["p_zero"]))
|
||||
S = pd.DataFrame(rows)
|
||||
k = int((S["p50"] - S["p50"].median()).abs().idxmin())
|
||||
OFF_M, PH_M, LEV_M = int(S.loc[k, "off"]), int(S.loc[k, "ph"]), float(S.loc[k, "lev"])
|
||||
if verbose:
|
||||
print(f" banda RI-DERIVATA ({time.time()-t:.0f}s) P(>=50/g) mediana "
|
||||
f"{S['p50'].median():.1%} [{np.percentile(S['p50'],10):.1%}, "
|
||||
f"{np.percentile(S['p50'],90):.1%}], P(zero) {S['pz'].median():.1%} "
|
||||
f"(PUB §37 {PUB['p50g_fund']:.1%} / {PUB['pzero_fund']:.1%})")
|
||||
print(f" cella ri-derivata {(OFF_M, PH_M, LEV_M)} contro la costante {CELL_M} -> "
|
||||
f"{'COINCIDE' if (OFF_M, PH_M, LEV_M) == CELL_M else 'DIVERGE'}")
|
||||
else:
|
||||
OFF_M, PH_M, LEV_M = CELL_M
|
||||
if verbose:
|
||||
print(f" cella d'ancora MEDIANA ereditata da `r0822d_gate_c`: {CELL_M} "
|
||||
f"(offset min, fase, leva). `--band` la ri-deriva dalle 69 celle.")
|
||||
fM = GC.fvec_for(W_A, I, rate, OFF_M, xs_ann)
|
||||
R_M0, G_M = AP.rg_off(W_A, I, XSP[PH_M], OFF_M)
|
||||
R_M = R_M0 - fM
|
||||
rb_full = FD.book_75_25(rate, alloc=654.0)
|
||||
if rb_full.index.tz is None:
|
||||
rb_full.index = rb_full.index.tz_localize("UTC")
|
||||
rb = np.nan_to_num(rb_full.reindex(I).values.astype(float))
|
||||
rngb = np.random.default_rng(51224)
|
||||
nb = int(np.ceil(HORIZON_DAYS / 20))
|
||||
st = rngb.integers(0, len(I) - 20, size=(N_LAD, nb))
|
||||
BOOT = (st[:, :, None] + np.arange(20)[None, None, :]).reshape(N_LAD, -1)[:, :HORIZON_DAYS]
|
||||
return dict(I=I, R_M=R_M, G_M=G_M, LEV_M=LEV_M, OFF_M=OFF_M, PH_M=PH_M,
|
||||
rb=rb, BOOT=BOOT, band=S)
|
||||
|
||||
|
||||
# ============================================================== 3. GLI SCENARI DI QUALIFICAZIONE
|
||||
# Ogni riga e' un'IPOTESI, con la sua fonte e il suo grado. NESSUNA e' "la risposta".
|
||||
# Ricerca documentale del 23/08 (15 fra ricerche e fetch): **nessuna fonte PRIMARIA italiana
|
||||
# sulle prop firm** — nessuna circolare, risoluzione o interpello dell'Agenzia delle Entrate che
|
||||
# qualifichi il profit share di un funded account. Due fonti professionali lo dichiarano
|
||||
# espressamente ("mancano chiarimenti ufficiali"). Le fonti professionali convergono sull'area
|
||||
# LAVORO AUTONOMO; l'ipotesi "reddito finanziario 26%" e' sostenuta da UNA sola fonte, la meno
|
||||
# autorevole del corpus, che nello stesso paragrafo afferma una ritenuta alla fonte del 26% da
|
||||
# parte della firm estera — quasi certamente falsa (un non residente senza stabile organizzazione
|
||||
# non e' sostituto d'imposta ex d.P.R. 600/1973).
|
||||
|
||||
def scenari() -> list[dict]:
|
||||
"""(etichetta, funzione netta, grado della fonte). Ordinate per aliquota effettiva crescente
|
||||
a EUR 18.250 lordi/anno (= EUR 50/giorno, il bersaglio del progetto)."""
|
||||
return [
|
||||
dict(k="S0", lab="nessuna imposta (CONTROLLO, non uno scenario)",
|
||||
fn=net_flat(0.0), src="controllo", tag="CTRL"),
|
||||
dict(k="S1", lab="forfettario 5% start-up, coeff 67% (ATECO 82.99)",
|
||||
fn=net_forf(0.05, 0.67), src="PROFESSIONALE (coeff.), ATECO non motivato", tag=""),
|
||||
dict(k="S2", lab="forfettario 5% start-up, coeff 78% (ATECO 66.xx/74.90.99)",
|
||||
fn=net_forf(0.05, 0.78), src="PROFESSIONALE (coeff.), ATECO non motivato", tag=""),
|
||||
dict(k="S3", lab="sostitutiva 26% — art. 67 c-quater (redditi diversi finanz.)",
|
||||
fn=net_flat(0.26), src="SECONDARIA: UNA fonte, non motivata", tag=""),
|
||||
dict(k="S4", lab="forfettario 15% a regime, coeff 78%",
|
||||
fn=net_forf(0.15, 0.78), src="PROFESSIONALE", tag=""),
|
||||
dict(k="S5", lab="lav.aut. OCCASIONALE, INPS 1/3, nessun altro reddito",
|
||||
fn=net_prog(0.0, "occasionale"), src="PROFESSIONALE: l'ipotesi piu' sostenuta",
|
||||
tag="OCC"),
|
||||
dict(k="S6", lab="sostitutiva 33% c-sexies = IL FORFAIT DEL PROGETTO OGGI",
|
||||
fn=net_flat(0.33), src="aliquota primaria, CATEGORIA senza alcuna fonte",
|
||||
tag="PROGETTO"),
|
||||
dict(k="S7", lab="lav.aut. OCCASIONALE, INPS 1/3, altro reddito EUR 30.000",
|
||||
fn=net_prog(30_000.0, "occasionale"), src="PROFESSIONALE + assunzione sul reddito",
|
||||
tag="OCC30"),
|
||||
dict(k="S8", lab="lav.aut. ABITUALE, IRPEF ord. + INPS PIENA, nessun altro reddito",
|
||||
fn=net_prog(0.0, "piena"), src="PROFESSIONALE", tag=""),
|
||||
dict(k="S9", lab="lav.aut. ABITUALE, IRPEF ord. + INPS PIENA, altro reddito EUR 30.000",
|
||||
fn=net_prog(30_000.0, "piena"), src="il caso PEGGIORE documentabile", tag="PEGGIO"),
|
||||
]
|
||||
|
||||
|
||||
def aliq_eff(fn, lordo_eur: float, spese_eur: float = 0.0) -> float:
|
||||
"""Aliquota effettiva implicita di una `netfn` su un lordo annuo in EUR, incassato in 12
|
||||
rate mensili uguali (come fa la scala di conti), con `spese_eur` di quote nell'anno."""
|
||||
ann = np.zeros(1)
|
||||
tot_net = 0.0
|
||||
rata = lordo_eur * EURUSD / 12.0
|
||||
sp = np.array([spese_eur * EURUSD])
|
||||
for _ in range(12):
|
||||
g = np.array([rata])
|
||||
tot_net += float(fn(g, ann, sp)[0])
|
||||
ann = ann + g
|
||||
lordo_usd = lordo_eur * EURUSD
|
||||
return 1.0 - tot_net / lordo_usd if lordo_usd else 0.0
|
||||
|
||||
|
||||
# ==================================================================================== 4. MAIN
|
||||
|
||||
TAU_GRID = (0.00, 0.20, 0.26, 0.33, 0.45, 0.60, 0.80, 1.00)
|
||||
|
||||
|
||||
def cross(taus: list[float], vals: list[float], soglia: float) -> float | None:
|
||||
"""Aliquota a cui la curva (decrescente) taglia `soglia`, per interpolazione lineare."""
|
||||
for i in range(1, len(taus)):
|
||||
a, b = vals[i - 1], vals[i]
|
||||
if (a - soglia) * (b - soglia) <= 0 and a != b:
|
||||
return taus[i - 1] + (taus[i] - taus[i - 1]) * (a - soglia) / (a - b)
|
||||
return None
|
||||
|
||||
|
||||
def main() -> None:
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
print("=" * 104)
|
||||
print(" §63 FISCO-PAYOUT — l'aliquota sui payout funded e' un FORFAIT del 33% mai")
|
||||
print(" giustificato, ed e' l'aliquota di una CATEGORIA che sul canale funded non esiste.")
|
||||
print(" Non si conclude quale sia: si misura QUANTO VALE LA RISPOSTA. Non e' un parere fiscale.")
|
||||
print("=" * 104)
|
||||
print(" ATTESE REGISTRATE PRIMA: A1 l'EV del singolo biglietto e' ESATTAMENTE lineare in")
|
||||
print(" (1-tau) [falsificabile al bit]; A2 la SCALA di conti NO, perche' i payout ricomprano")
|
||||
print(" biglietti; A3 l'EV resta positivo oltre il 70% -> la gamba (c1) non e' cio' che morde;")
|
||||
print(" A4 la soglia di ribaltamento cade DENTRO la banda plausibile -> domanda BLOCCANTE;")
|
||||
print(" A5 l'effettiva di uno scaglione progressivo a EUR 18k/anno e' SOTTO il 33% del")
|
||||
print(" forfait attuale, ma sale col reddito preesistente -> la stessa qualificazione da'")
|
||||
print(" due risposte diverse a seconda di chi la riceve.")
|
||||
|
||||
hr("§0. IL CONTESTO DI §37, RICALCOLATO (non copiato) — e la cella d'ancora mediana")
|
||||
B = build()
|
||||
R_M, G_M, LEV_M, BOOT, rb = B["R_M"], B["G_M"], B["LEV_M"], B["BOOT"], B["rb"]
|
||||
print(f" cella in uso: offset {B['OFF_M']} min, fase {B['PH_M']}, leva {LEV_M:.2f}x")
|
||||
|
||||
# ---------------------------------------------------------------- §1 dove entra l'imposta
|
||||
hr("§1. DOVE ENTRA L'IMPOSTA — tre righe in tutto il canale funded, e una TRAPPOLA")
|
||||
print(" `r0725_prop_ladder:269` net = gross * (1.0 - TAX_RATE)")
|
||||
print(" `r0725_prop_coupled:414` net = gain.sum(axis=1) * SPLIT * (1.0 - TAX_RATE)")
|
||||
print(" `r0822_prop_alloc:339` payout += ... * SPLIT * (1.0 - TAX_RATE)")
|
||||
print(f" `TAX_RATE` = {GC.TAX_RATE:.2f}, importato PER VALORE da `r0725_capcurve`, dove il")
|
||||
print(" commento cita la L.207/2024 — cioe' la norma sulle CRIPTO-ATTIVITA'. Il canale")
|
||||
print(" funded ha ereditato l'aliquota del libro proprio senza che nessuno la giustificasse.")
|
||||
print("\n ⚠ TRAPPOLA MISURATA (e' il motivo per cui questo filone NON fa uno sweep globale):")
|
||||
_sav = GC.TAX_RATE
|
||||
b33 = GC.book_road(rb, BOOT, pl.START_EUR, 500.0)
|
||||
GC.TAX_RATE = 0.99
|
||||
b99 = GC.book_road(rb, BOOT, pl.START_EUR, 500.0)
|
||||
l99 = GC.ladder(R_M, G_M, N_LAD, LEV_M, SEED_LAD, refund=True, deposit_eur=500.0,
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
GC.TAX_RATE = _sav
|
||||
print(f" `GC.book_road` ha `tax: float = TAX_RATE` come DEFAULT, valutato all'import:")
|
||||
print(f" portando `GC.TAX_RATE` da 0,33 a 0,99 la strada LIBRO NON si muove di un dollaro")
|
||||
print(f" (mediana ${b33['med_cash']:,.0f} -> ${b99['med_cash']:,.0f}) mentre la strada")
|
||||
print(f" BIGLIETTO crolla (mediana ${l99['med_cash']:,.0f}).")
|
||||
print(" Chi facesse 'uno sweep sul fisco' patchando la costante globale tasserebbe UNA")
|
||||
print(" SOLA delle due strade e leggerebbe un ribaltamento inesistente. Qui le due")
|
||||
print(" aliquote sono DUE knob separati e dichiarati, che e' anche la verita' fiscale:")
|
||||
print(" il libro proprio e il payout funded stanno in due categorie diverse.")
|
||||
|
||||
# ---------------------------------------------------------------- §2 controlli
|
||||
hr("§2. CONTROLLI — un rilevatore che non trova nulla e' indistinguibile da uno rotto")
|
||||
ref = GC.ladder(R_M, G_M, N_LAD, LEV_M, SEED_LAD, refund=True, deposit_eur=500.0,
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
mine = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, net_flat(GC.TAX_RATE), refund=True,
|
||||
deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
d = float(np.abs(ref["cash"] - mine["cash"]).max())
|
||||
print(f" (a) BIT-EXACT: `ladder_tax` con aliquota piatta 33% contro `GC.ladder` (l'originale")
|
||||
print(f" di §37), percorso per percorso: max|diff| = {d:.3e} -> "
|
||||
f"{'IDENTICO' if d == 0.0 else 'DIVERGE — STOP'}")
|
||||
if d != 0.0:
|
||||
return
|
||||
print(" (b) CONTROLLO POSITIVO: il knob morde — le righe 0% e 100% della griglia di §4")
|
||||
print(" (a 100% la cassa non va a zero: restano i versamenti non spesi e i depositi")
|
||||
print(" rimborsati. Un'imposta totale non confisca il capitale versato, e il modello")
|
||||
print(" lo rispetta: e' il controllo che il knob colpisce il REDDITO e non il conto.)")
|
||||
print(f" (c) L'aliquota effettiva delle netfn, controllata su un caso a mano:")
|
||||
for lab, fn, atteso in (("piatta 26%", net_flat(0.26), 0.26),
|
||||
("piatta 33%", net_flat(0.33), 0.33)):
|
||||
got = aliq_eff(fn, 18_250.0)
|
||||
print(f" {lab:>12}: misurata {got:.4f} attesa {atteso:.4f} "
|
||||
f"{'OK' if abs(got-atteso) < 1e-12 else 'ERRORE'}")
|
||||
|
||||
# ---------------------------------------------------------------- §3 EV del biglietto
|
||||
hr("§3. L'EV DEL BIGLIETTO CONTRO L'ALIQUOTA — e la REPLICA di §37 prima di ogni numero nuovo")
|
||||
rows = []
|
||||
for lev_ev in (0.50, 0.75, 1.00):
|
||||
for lev_fu in (0.50, 0.75, 1.00):
|
||||
r = GC.ticket_mc(R_M, G_M, lev_ev=lev_ev, lev_fu=lev_fu, notional=100_000.0)
|
||||
rows.append(dict(lev_ev=lev_ev, lev_fu=lev_fu, **r))
|
||||
T = pd.DataFrame(rows)
|
||||
best = T.loc[T["e_payout"].idxmax()]
|
||||
LEV_EV, LEV_FU = float(best["lev_ev"]), float(best["lev_fu"])
|
||||
e33 = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0)
|
||||
ev33 = GC.ev_three_ways(e33, PRICE_100K)
|
||||
print(f" leve argmax E[payout]: eval {LEV_EV:.2f}x / funded {LEV_FU:.2f}x (come §37)")
|
||||
print(f" {'convenzione':>26} {'oggi':>10} {'PUBBLICATO §37':>16} {'delta':>10}")
|
||||
for k, lab, p in (("sunk", "(i) spesa persa", PUB["ev_sunk"]),
|
||||
("at_pass", "(ii) rimborso al pass", PUB["ev_at_pass"]),
|
||||
("at_payout", "(iii) rimborso al payout", PUB["ev_at_payout"])):
|
||||
v = ev33[k]
|
||||
print(f" {lab:>26} ${v:>+9,.0f} ${p:>+15,.0f} {v-p:>+10,.0f}")
|
||||
print(" Lo scarto (~+3%) e' lo stesso vintage di feed di §37: +1 giorno di barre. La")
|
||||
print(" macchineria e' quella. >>> REPLICA RIUSCITA 3/3.")
|
||||
|
||||
_sav = GC.TAX_RATE
|
||||
GC.TAX_RATE = 0.0
|
||||
e0 = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0)
|
||||
GC.TAX_RATE = _sav
|
||||
e_gross = e0["e_payout"]
|
||||
print(f"\n E[payout] LORDO (aliquota 0): ${e_gross:,.0f}. P(pass) {e0['p_pass']:.1%}, "
|
||||
f"P(payout) {e0['p_payout']:.1%} — IDENTICHE a quelle al 33% "
|
||||
f"({'si' if (e0['p_pass'], e0['p_payout']) == (e33['p_pass'], e33['p_payout']) else 'NO'}): "
|
||||
f"l'imposta non cambia QUALI eventi accadono.")
|
||||
print(f"\n {'aliquota':>9} {'E[payout] netto':>16} {'atteso lineare':>16} {'|scarto|':>10} "
|
||||
f"{'EV spesa persa':>16} {'EV al payout':>14}")
|
||||
lin_ok = True
|
||||
for tau in TAU_GRID:
|
||||
GC.TAX_RATE = tau
|
||||
rt = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0)
|
||||
GC.TAX_RATE = _sav
|
||||
pred = e_gross * (1.0 - tau)
|
||||
lin_ok &= abs(rt["e_payout"] - pred) < 1e-9
|
||||
e3 = GC.ev_three_ways(rt, PRICE_100K)
|
||||
print(f" {tau:>8.0%} ${rt['e_payout']:>15,.1f} ${pred:>15,.1f} "
|
||||
f"{abs(rt['e_payout']-pred):>10.2e} ${e3['sunk']:>+15,.0f} ${e3['at_payout']:>+13,.0f}")
|
||||
tau_ev0 = 1.0 - PRICE_100K / e_gross
|
||||
print(f"\n >>> ATTESA A1 ('lineare AL BIT'): "
|
||||
f"{'CONFERMATA' if lin_ok else 'SMENTITA'} — scarto max < 1e-9 su tutta la griglia.")
|
||||
print(" Meccanismo: la soglia di prelievo ($100 di quota trader) e' sul LORDO, quindi")
|
||||
print(" l'imposta non sposta nessun evento. E' l'unico punto del canale dove il fisco")
|
||||
print(" e' un semplice fattore moltiplicativo.")
|
||||
print(f" >>> ATTESA A3: l'EV del biglietto (spesa persa) resta positivo fino a "
|
||||
f"**tau = {tau_ev0:.1%}** -> {'CONFERMATA' if tau_ev0 > 0.70 else 'SMENTITA'}.")
|
||||
print(" La gamba (c1) del `GATE PROP-01` NON e' cio' che il fisco puo' far cadere:")
|
||||
print(" nessuna qualificazione plausibile arriva a quell'aliquota.")
|
||||
|
||||
# ---------------------------------------------------------------- §4 la scala di conti
|
||||
hr("§4. LA SCALA DI CONTI — dove la linearita' si ROMPE (i payout ricomprano biglietti)")
|
||||
print(" Confronto APPAIATO (stesso bootstrap `BOOT` a tutte le aliquote e in entrambe le")
|
||||
print(" strade). 'atteso lineare' = il risultato che si avrebbe se l'imposta fosse solo un")
|
||||
print(" fattore sul flusso, cioe' la mediana a tau=0 riscalata di (1-tau).")
|
||||
lad = {}
|
||||
for dep in (0.0, 500.0):
|
||||
base = None
|
||||
print(f"\n --- versamento EUR {dep:,.0f}/mese")
|
||||
print(f" {'aliquota':>9} {'EUR/g med':>10} {'P(>=50/g)':>10} {'P(zero)':>9} "
|
||||
f"{'cassa mediana':>14} {'media':>12} {'atteso lin. (med)':>18} {'scarto':>9}")
|
||||
for tau in TAU_GRID:
|
||||
r = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, net_flat(tau), refund=True,
|
||||
deposit_eur=dep, min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
lad[(dep, tau)] = r
|
||||
if base is None:
|
||||
base = r
|
||||
netto_dep = dep * EURUSD * (HORIZON_DAYS // 30) + pl.START_EUR * EURUSD
|
||||
lin = netto_dep + (base["med_cash"] - netto_dep) * (1.0 - tau)
|
||||
print(f" {tau:>8.0%} {r['med']:>10.2f} {r['p_target']:>10.1%} {r['p_zero']:>9.1%} "
|
||||
f"${r['med_cash']:>13,.0f} ${r['mean_cash']:>11,.0f} ${lin:>17,.0f} "
|
||||
f"{(r['med_cash']-lin)/max(abs(lin),1):>+9.1%}")
|
||||
print("\n ('atteso lineare' tratta il capitale VERSATO come non tassabile — lo e': l'imposta")
|
||||
print(" colpisce il payout, non il bonifico. Lo scarto misura quindi solo la COMPOSIZIONE.)")
|
||||
|
||||
# ---------------------------------------------------------------- §5 la soglia
|
||||
hr("§5. LA SOGLIA — a quale aliquota il BIGLIETTO smette di battere il LIBRO")
|
||||
print(" La strada LIBRO non dipende dall'aliquota sui payout: e' l'ALTRO knob (33% cripto,")
|
||||
print(" o 26% se i derivati fossero c-quater — domanda gia' aperta dal 07/08). Percio' la")
|
||||
print(" soglia si legge per ogni valore del fisco del LIBRO.")
|
||||
out = {}
|
||||
|
||||
def _f(x):
|
||||
return f"tau = {x:.1%}" if x is not None else "MAI (fuori dalla griglia 0-100%)"
|
||||
|
||||
for dep in (0.0, 500.0):
|
||||
print(f"\n --- versamento EUR {dep:,.0f}/mese")
|
||||
taus = list(TAU_GRID)
|
||||
med = [lad[(dep, t)]["med_cash"] for t in taus]
|
||||
mean = [lad[(dep, t)]["mean_cash"] for t in taus]
|
||||
xmean = [float(lad[(dep, t)]["excess"].mean()) for t in taus]
|
||||
for tax_book in (0.26, 0.33):
|
||||
Bk = GC.book_road(rb, BOOT, pl.START_EUR, dep, tax=tax_book)
|
||||
bx = float((Bk["cash"] - Bk["contributed"]).mean())
|
||||
cm = cross(taus, med, Bk["med_cash"])
|
||||
cme = cross(taus, mean, Bk["mean_cash"])
|
||||
cx = cross(taus, xmean, bx)
|
||||
out[(dep, tax_book)] = (Bk, cm, cme, cx)
|
||||
print(f" LIBRO al {tax_book:.0%}: mediana ${Bk['med_cash']:>9,.0f} "
|
||||
f"media ${Bk['mean_cash']:>9,.0f} eccedenza media ${bx:>8,.0f}")
|
||||
print(f" soglia sulla MEDIA {_f(cme)} | sull'ECCEDENZA sul versato {_f(cx)} | "
|
||||
f"sulla mediana {_f(cm)}")
|
||||
print("\n ('eccedenza sul versato' = cassa finale meno tutto cio' che e' entrato: e' la")
|
||||
print(" metrica PIU' SENSIBILE all'aliquota, perche' toglie dai due lati i bonifici, che")
|
||||
print(" il fisco non tocca. Se la soglia non cade dentro la banda nemmeno LI', non ci cade.)")
|
||||
print("\n ⚠ La MEDIANA della strada-biglietto e' BIMODALE (§37 lo misura: `P(cassa<$249)` si")
|
||||
print(" muove liscia mentre la mediana salta di un ordine di grandezza appena quella massa")
|
||||
print(" passa il 50%). Una soglia letta sulla mediana e' quindi il punto in cui una massa")
|
||||
print(" di probabilita' attraversa il 50%, non un meccanismo. **La soglia da citare e'")
|
||||
print(" quella sulla MEDIA**, che e' continua; la mediana si riporta come contorno.")
|
||||
|
||||
# ---------------------------------------------------------------- §6 gli scenari
|
||||
hr("§6. LE QUALIFICAZIONI IN CAMPO — e dove cadono rispetto alla soglia")
|
||||
print(" ⚠ NESSUNA FONTE PRIMARIA ESISTE (ricerca del 23/08): nessun interpello, nessuna")
|
||||
print(" circolare, nessuna risoluzione dell'Agenzia sulle prop firm. Due fonti")
|
||||
print(" professionali lo dichiarano espressamente. Cio' che segue e' una BANDA di")
|
||||
print(" ipotesi, non una stima.")
|
||||
SC = scenari()
|
||||
print(f"\n {'':>3} {'scenario':>58} {'eff.@18k':>9} {'eff.@30k':>9} {'grado fonte':>44}")
|
||||
for s in SC:
|
||||
print(f" {s['k']:>3} {s['lab']:>58} {aliq_eff(s['fn'], 18_250.0):>9.1%} "
|
||||
f"{aliq_eff(s['fn'], 30_000.0):>9.1%} {s['src']:>44}")
|
||||
print("\n (eff.@18k = EUR 50/giorno, il bersaglio del progetto; eff.@30k = un anno buono.)")
|
||||
|
||||
print(f"\n Effetto sulla scala di conti, versamento EUR 500/mese (l'unica riga su cui §37")
|
||||
print(f" ha concluso 'il biglietto batte il versare'):")
|
||||
Bk33 = out[(500.0, 0.33)][0]
|
||||
print(f" {'':>3} {'aliquota eff.':>13} {'EUR/g med':>10} {'P(>=50/g)':>10} {'P(zero)':>9} "
|
||||
f"{'cassa mediana':>14} {'media':>12} {'vs LIBRO(33%)':>14}")
|
||||
sc_rows = []
|
||||
for s in SC:
|
||||
r = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, s["fn"], refund=True,
|
||||
deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
win = "BIGLIETTO" if r["mean_cash"] > Bk33["mean_cash"] else "LIBRO"
|
||||
sc_rows.append(dict(k=s["k"], tag=s["tag"], eff=aliq_eff(s["fn"], 18_250.0), **r))
|
||||
print(f" {s['k']:>3} {aliq_eff(s['fn'], 18_250.0):>13.1%} {r['med']:>10.2f} "
|
||||
f"{r['p_target']:>10.1%} {r['p_zero']:>9.1%} ${r['med_cash']:>13,.0f} "
|
||||
f"${r['mean_cash']:>11,.0f} {win:>14}")
|
||||
SCR = pd.DataFrame(sc_rows)
|
||||
lo, hi = SCR["eff"].iloc[1:].min(), SCR["eff"].max()
|
||||
cme = out[(500.0, 0.33)][2]
|
||||
cxx = out[(500.0, 0.33)][3]
|
||||
print(f"\n Banda plausibile delle aliquote effettive (escluso il controllo): "
|
||||
f"{lo:.1%} - {hi:.1%}.")
|
||||
print(f" Soglia di ribaltamento (LIBRO al 33%): sulla MEDIA "
|
||||
f"{'tau = ' + format(cme, '.1%') if cme is not None else 'FUORI dalla griglia 0-100%'}"
|
||||
f" | sull'ECCEDENZA "
|
||||
f"{'tau = ' + format(cxx, '.1%') if cxx is not None else 'FUORI dalla griglia 0-100%'}")
|
||||
dentro = (cme is not None) and (lo <= cme <= hi)
|
||||
print(f" >>> ATTESA A4 ('la soglia cade DENTRO la banda'): "
|
||||
f"{'CONFERMATA' if dentro else 'REFUTATA'}")
|
||||
e_pro = float(SCR.loc[SCR["tag"] == "PROGETTO", "eff"].iloc[0])
|
||||
e_occ = float(SCR.loc[SCR["tag"] == "OCC", "eff"].iloc[0])
|
||||
e_o30 = float(SCR.loc[SCR["tag"] == "OCC30", "eff"].iloc[0])
|
||||
print(f" >>> ATTESA A5 ('la progressiva a EUR 18k sta SOTTO il forfait 33% del progetto'): "
|
||||
f"occasionale {e_occ:.1%} contro forfait {e_pro:.1%} -> "
|
||||
f"{'CONFERMATA' if e_occ < e_pro else 'REFUTATA'}.")
|
||||
print(f" E il seguito e' il punto trasferibile: la STESSA qualificazione, con un reddito")
|
||||
print(f" preesistente di EUR 30.000, sale a {e_o30:.1%} — "
|
||||
f"{e_o30/e_occ:.2f}x. **L'aliquota non e' una proprieta' della strategia, e' una")
|
||||
print(f" proprieta' del contribuente**, e il canale funded e' l'unico pezzo del")
|
||||
print(f" progetto in cui questo e' vero (le plusvalenze cripto hanno aliquota fissa).")
|
||||
|
||||
hr("§6.2 LA CATEGORIA CAMBIA ANCHE LA BASE, non solo l'aliquota")
|
||||
print(" art. 71 c.2 TUIR (testo verificato in sessione): i redditi di cui all'art. 67 c.1")
|
||||
print(" lett. l) sono 'la DIFFERENZA fra l'ammontare percepito nel periodo di imposta e le")
|
||||
print(" spese specificamente inerenti alla loro produzione' -> **sotto lavoro autonomo le")
|
||||
print(" quote di challenge SI DEDUCONO**; sotto un'imposta sostitutiva su reddito")
|
||||
print(" finanziario NO (una challenge persa non e' una minusvalenza da cripto-attivita'),")
|
||||
print(" e sotto forfettario nemmeno (le sostituisce il coefficiente).")
|
||||
sp_med = float(lad[(500.0, 0.33)]["spent"])
|
||||
sp_anno = sp_med / 3.0 / EURUSD
|
||||
print(f"\n Quote comprate in media su 36 mesi: ${sp_med:,.0f} = EUR {sp_anno:,.0f}/anno.")
|
||||
print(f" {'scenario':>52} {'senza deduzione':>16} {'con deduzione':>14} {'delta':>8}")
|
||||
for lab, fn_nd, fn_d in (
|
||||
("lav.aut. OCCASIONALE, nessun altro reddito",
|
||||
net_prog(0.0, "occasionale", deduci=False), net_prog(0.0, "occasionale")),
|
||||
("lav.aut. ABITUALE INPS piena, altro reddito 30k",
|
||||
net_prog(30_000.0, "piena", deduci=False), net_prog(30_000.0, "piena"))):
|
||||
a = aliq_eff(fn_nd, 18_250.0, sp_anno)
|
||||
b = aliq_eff(fn_d, 18_250.0, sp_anno)
|
||||
print(f" {lab:>52} {a:>16.2%} {b:>14.2%} {b-a:>+8.2%}")
|
||||
print(" -> la categoria con l'aliquota PIU' ALTA e' anche l'unica che deduce il costo dei")
|
||||
print(" biglietti: l'ordine fra le qualificazioni non e' l'ordine fra le aliquote.")
|
||||
|
||||
hr("§6.1 ROBUSTEZZA — i due numeri della ricerca che NON ho verificato su fonte primaria")
|
||||
print(" (a) secondo scaglione IRPEF 2026: 33% (L.199/2025) contro il 35% del 2025.")
|
||||
for lab, sg in (("33% (2026)", IRPEF_SCAGLIONI), ("35% (2025)", IRPEF_2025)):
|
||||
f1 = net_prog(0.0, "occasionale", sg)
|
||||
f2 = net_prog(30_000.0, "occasionale", sg)
|
||||
print(f" {lab:>11}: occasionale {aliq_eff(f1, 18_250.0):.2%} "
|
||||
f"con altro reddito 30k {aliq_eff(f2, 18_250.0):.2%}")
|
||||
print(" (b) chi versa i 2/3 di Gestione Separata con committente ESTERO — buco documentale:")
|
||||
for lab, inps in (("committente versa 2/3", "occasionale"), ("tutto sul prestatore", "piena")):
|
||||
print(f" {lab:>22}: eff.@18k "
|
||||
f"{aliq_eff(net_prog(0.0, inps), 18_250.0):>6.1%} "
|
||||
f"@30k {aliq_eff(net_prog(0.0, inps), 30_000.0):>6.1%}")
|
||||
|
||||
# ---------------------------------------------------------------- §7 verdetto
|
||||
hr("§7. VERDETTO — e la domanda, scritta in modo che una risposta sia possibile")
|
||||
r33 = lad[(500.0, 0.33)]
|
||||
print(f" 1. Il forfait 33% NON e' l'aliquota di questa cosa: sul funded il trader non")
|
||||
print(f" possiede il conto ne' le posizioni, non c'e' realizzo di cripto-attivita', e")
|
||||
print(f" l'art. 67 c-sexies (33%) e c-quater (26%) — le due caselle su cui il progetto")
|
||||
print(f" discute per il LIBRO — sono entrambe FUORI CATEGORIA qui. Le fonti")
|
||||
print(f" professionali convergono su LAVORO AUTONOMO. Nessuna prassi ufficiale esiste.")
|
||||
print(f" 2. La conclusione di §37 ('il biglietto batte il versare' a EUR 500/mese) "
|
||||
f"{'REGGE' if cme is None or cme > hi else 'NON REGGE'} "
|
||||
f"su tutta la banda plausibile.")
|
||||
print(f" 3. Il costo della QUESTIONE, misurato: passare dall'aliquota piu' bassa a quella")
|
||||
print(f" piu' alta della banda vale, sulla cassa mediana a 36 mesi,")
|
||||
lo_r = SCR.loc[SCR["eff"].iloc[1:].idxmin()]
|
||||
hi_r = SCR.loc[SCR["eff"].idxmax()]
|
||||
print(f" ${lo_r['med_cash']:,.0f} -> ${hi_r['med_cash']:,.0f} "
|
||||
f"({(hi_r['med_cash']/max(lo_r['med_cash'],1)-1)*100:+.0f}%), e su P(>=50/g) "
|
||||
f"{lo_r['p_target']:.1%} -> {hi_r['p_target']:.1%}.")
|
||||
d_eur = (hi_r["med_cash"] - lo_r["med_cash"]) / EURUSD / (HORIZON_DAYS / 365.0) / 365.0
|
||||
print(f" In EUR/GIORNO di rendita a 36 mesi: **{d_eur:+.2f} EUR/giorno** fra i due")
|
||||
print(f" estremi della banda, contro un bersaglio di 50.")
|
||||
print(f" 4. Al 33% di oggi la scala di conti da' EUR/g mediana {r33['med']:.2f} e "
|
||||
f"P(>=50/g) {r33['p_target']:.1%}: **l'aliquota non e' cio' che tiene lontano il")
|
||||
print(f" bersaglio**, lo tiene lontano la distribuzione.")
|
||||
|
||||
print("\n LA DOMANDA AL COMMERCIALISTA (accanto a quella gia' aperta dal 07/08 sui")
|
||||
print(" derivati, 26% contro 33% — e questa e' una domanda DIVERSA, non la stessa):")
|
||||
print(" Q1. Il profit share pagato da una prop firm estera a chi NON possiede il conto,")
|
||||
print(" NON possiede le posizioni e NON apporta capitale e': art. 67 c.1 lett. l),")
|
||||
print(" art. 53, art. 55, oppure art. 67 c.1 lett. c-quater TUIR? **Indichi la lettera.**")
|
||||
print(" Q2. Una prop firm non residente e senza stabile organizzazione puo' operare una")
|
||||
print(" ritenuta italiana sul payout? (SI'/NO)")
|
||||
print(" Q3. Superata la soglia di EUR 5.000 di compensi occasionali, con committente")
|
||||
print(" (a) UE e (b) extra-UE: l'aliquota di Gestione Separata che grava sul")
|
||||
print(" PRESTATORE e' 1/3 di 26,07% o l'intero 26,07%? (una risposta per caso)")
|
||||
print(" Q4. Con partita IVA: quale ATECO, e quindi quale coefficiente forfettario,")
|
||||
print(" 78% o 67%? (una sigla e una percentuale)")
|
||||
print(" Q5. Il funded account va in quadro RW / IVAFE? (SI'/NO) Se no, l'obbligo si")
|
||||
print(" limita al conto estero su cui incasso?")
|
||||
print("\n ONESTA' OBBLIGATORIE:")
|
||||
print(" * questo NON e' un parere fiscale, e nessuna riga qui sopra e' una consulenza.")
|
||||
print(" * l'aliquota EFFETTIVA degli scenari progressivi e' calcolata SENZA detrazioni")
|
||||
print(" (conservativo: le detrazioni la abbassano) e con addizionali al minimo di legge.")
|
||||
print(" * il modello tassa i payout dell'anno via via che arrivano, non a saldo: toglie")
|
||||
print(" liquidita' prima del dovuto, quindi e' conservativo sulla ricomposizione.")
|
||||
print(" * tutte le assunzioni di §37 restano dentro: morte-firm 10%/anno (mai stimata),")
|
||||
print(" cap $200k/trader, XS01 su U13 fuori campione, ancora giornaliera di TP01 fuori")
|
||||
print(" dalla banda. Il fisco e' UN parametro fra questi, e non il piu' incerto.")
|
||||
print(f"\n fatto in {time.time()-T0:.0f}s")
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,794 @@
|
||||
"""r0823b_ladder_redo — §60 LADDER-REDO: la politica multi-conto e' ancora MISTO? (2026-08-23)
|
||||
|
||||
LA DOMANDA
|
||||
----------
|
||||
Il 2026-07-25 (`r0725_prop_ladder.py` + `r0725_prop_coupled.py`) il progetto scelse la politica
|
||||
multi-conto **MISTO** (sleeve diversi su conti diversi) contro CONC-DIV, SPARSO e CONC-2SL:
|
||||
|
||||
MISTO 10,70 EUR/g mediana, P(>=50/g) 20,7%, P(zero) 33,4%
|
||||
> CONC-DIV 5,70 / 17,8% / 33,4%
|
||||
> SPARSO 0,00 / 16,8% / 66,0%
|
||||
> CONC-2SL 0,00 / 13,1% / 55,6% (close-only, leva 1,00x)
|
||||
|
||||
Da allora il numero operativo del canale funded e' passato **da 42% a 2,6%** (fattore 16) per
|
||||
tre correzioni misurate in due giorni:
|
||||
(a) universo XS01 **fuori campione** — 6 delle 19 gambe non esistevano nel 2021-23 e valevano
|
||||
il **42% del J pubblicato** (§29);
|
||||
(b) **banda d'ancora di SKH01** — l'offset canonico e' al 91° pctl dei 23 (§32);
|
||||
(c) **funding** — mai modellato nel 2025, costa dJ -0,049 su 69/69 celle appaiate (§35, §37).
|
||||
Piu' due lenti che il 25/07 non aveva o aveva diverse: la **wick accoppiata** (misurata il
|
||||
25/07 sera, dopo il ladder) e il de-luck **x0,89** invece di x0,60 (misurato il 26/07).
|
||||
|
||||
**Nessuno ha ri-misurato la politica.** La conclusione "MISTO" e' stata EREDITATA.
|
||||
|
||||
LE ATTESE, REGISTRATE PRIMA DI MISURARE
|
||||
---------------------------------------
|
||||
A1. **La replica dell'ORDINE riuscira', quella dei LIVELLI no.** `pl.sleeve_panel` ri-deriva le
|
||||
serie dal feed corrente (+4 settimane dal 25/07): §37 ha gia' visto -11% su `r0725_hyro`
|
||||
per la stessa ragione. Mi aspetto livelli 10-30% piu' bassi e ordine identico.
|
||||
A2. **Il funding NON puo' ribaltare l'ordine, e semmai lo RAFFORZA.** Il costo di funding per
|
||||
sleeve e' misurato (§35/§37, a peso 1,0): TP01 2,10%/a, SKH01 2,32%/a, XS01 1,45%/a. Il
|
||||
costo medio di politica e' quindi CONC-2SL 2,16% > CONC-A 2,04% > CONC-DIV 1,98% >
|
||||
SPARSO 1,96% > **MISTO 1,82%** — cioe' il vincitore del 25/07 e' anche quello che paga
|
||||
MENO funding, ma lo spread e' solo **0,33 pp/anno** (un sesto del costo). Previsione:
|
||||
tutti i livelli scendono, l'ordine resta, il delta MISTO-vs-resto si allarga di poco e
|
||||
dentro il rumore.
|
||||
A3. **La correzione che PUO' ribaltare l'ordine e' XS01, non il funding.** MISTO e SPARSO
|
||||
poggiano su conti a **XS01 puro** (2/6 e 2/6 slot); se il drift di XS01 fuori campione e'
|
||||
piu' debole (Sharpe 1,04 e maxDD -19,2% contro -11,2% dello sleeve ufficiale, §29), sono
|
||||
proprio quelle politiche a perdere. Previsione: **se l'ordine cambia, cambia CONTRO
|
||||
MISTO/SPARSO e a favore di CONC-DIV / CONC-A**, e per l'universo, non per il funding.
|
||||
A4. **Il numero di conti e' il vero vincolo, e non e' stato mai misurato.** Con $654 di cassa
|
||||
e un biglietto HYRO $100k a $579 si compra **UN** conto e restano $75: mi aspetto che la
|
||||
stragrande maggioranza dei percorsi non arrivi MAI a due conti simultanei, e quindi che
|
||||
**MISTO e CONC-DIV, che condividono lo slot 0, siano quasi indistinguibili** finche' non
|
||||
entrano soldi. Previsione: la politica conta poco senza versamenti e molto con versamenti.
|
||||
A5. **Il deposito rimborsabile (§30) fa piu' differenza sulla SCALA che sull'EV**, perche' i
|
||||
$579 che tornano ricomprano un biglietto: +1-3pp su P(>=50/g), come previde §37.
|
||||
|
||||
COSA FA
|
||||
-------
|
||||
§1 REPLICA del 25/07 (`pl.simulate` close-only/indip, `pc.simulate` accoppiata).
|
||||
§2 CONTROLLI: `ladder_multi` bit-exact contro `pc.simulate`; controllo POSITIVO (una politica
|
||||
deliberatamente rotta deve finire ultima, o il confronto non ha potenza).
|
||||
§3 DECOMPOSIZIONE a un grado di liberta' per volta: lente -> de-luck -> universo/finestra ->
|
||||
funding. E' il metodo di §29: senza, non si sa QUALE correzione fa cosa.
|
||||
§4 BANDA D'ANCORA: 8 offset x 3 fasi (sottocampione DICHIARATO), con e senza funding, tutte
|
||||
le politiche insieme sugli STESSI sorteggi -> mediana delle differenze APPAIATE.
|
||||
§5 La previsione A2 sul funding, verificata.
|
||||
§6 LA DIMENSIONE MAI TESTATA: la traiettoria del NUMERO DI CONTI nel tempo, con quota
|
||||
rimborsabile e con/senza versamenti.
|
||||
§7 MDE, e verdetto.
|
||||
|
||||
CONVENZIONI DICHIARATE
|
||||
----------------------
|
||||
* Le POLITICHE sono quelle del 25/07, non ridefinite (altrimenti si misura una ridefinizione,
|
||||
non una correzione). Aggiunte due sole varianti, dichiarate: **CONC-A** = W_A 38/38/25 (il
|
||||
centro della regione robusta di §29, cioe' la configurazione su cui poggiano §32 e §37) e
|
||||
**MISTO-A** = MISTO col nucleo W_A al posto di book_div (separa "il nucleo" dal "mescolare").
|
||||
* Lente **ACCOPPIATA** ovunque nella parte corretta; close-only e indipendente solo come
|
||||
repliche/controlli. De-luck **x0,89** (conservativo: §32 nota che sulla dimensione d'ancora
|
||||
e' un doppio conteggio).
|
||||
* Leva **fissa** e uguale per tutte le politiche: il confronto e' appaiato, e `best_lev` per
|
||||
configurazione introdurrebbe un grado di liberta' diverso per politica. Girata a 1,00x
|
||||
(grid piena) e 0,75x (controllo).
|
||||
* Firm death 10%/anno, cap $200k/firm, fisco 33%, split 80% — tutte ereditate, nessuna scelta.
|
||||
* Bootstrap a blocchi (20 g) **condiviso**: stessi indici e stessi sorteggi di morte-firm per
|
||||
TUTTE le politiche -> differenze appaiate.
|
||||
|
||||
Rete: NESSUNA (`--no-net` forzato; cache funding e cache Binance gia' su disco).
|
||||
Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_ladder_redo.py`
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv:
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata (25/07)
|
||||
import r0725_prop_ladder as pl # noqa: E402 ladder originale + regole firm (25/07)
|
||||
import r0822_prop_alloc as PA # noqa: E402 bootstrap/J (22/08)
|
||||
import r0822b_prop_recal as PR # noqa: E402 (R,G) su pannello libero (22/08)
|
||||
import r0822b_xs01_oos as X # noqa: E402 motore XS01 + U13 Binance (22/08)
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01 (22/08)
|
||||
import r0822d_funding as FD # noqa: E402 funding (22/08)
|
||||
import r0822d_gate_c as GC # noqa: E402 funding per-sleeve + ladder a 1 cfg (22/08)
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
EURUSD = pl.EURUSD
|
||||
TAX_RATE = pl.TAX_RATE
|
||||
SPLIT = pl.SPLIT
|
||||
FIRMS = pl.FIRMS
|
||||
MAXC = pl.MAX_CONCURRENT # 6 slot
|
||||
HDAYS = pl.HORIZON_MONTHS * 30 # 1080
|
||||
DELUCK_NEW = PA.DELUCK # 0,89 (26/07)
|
||||
DELUCK_OLD = pl.DELUCK # 0,60 (25/07)
|
||||
TARGET = pl.TARGET_EUR_DAY
|
||||
MIN_PRICE = min(p for F in FIRMS for (_s, p) in F["tickets"])
|
||||
|
||||
# --- sottocampioni DICHIARATI (a priori, uniformi) -------------------------------------------
|
||||
OFFSETS = AP.OFFSETS[::3] # 8 degli 23 offset: 0,90,...,630 — uniforme a priori
|
||||
PHASES = GC.PHASES_SUB # (0,3,7) — lo stesso di §37
|
||||
N_PATHS = 1500 # risoluzione MC dichiarata (~+-1pp su P(>=50/g))
|
||||
N_PATHS_REP = 3000 # per la replica: identico al 25/07
|
||||
SEED = 20260725 # il seme del 25/07
|
||||
LEV_MAIN, LEV_ALT = 1.00, 0.75
|
||||
|
||||
# `--quick` = AUTO-TEST: esercita ogni ramo di codice in ~2 minuti. NON produce numeri da citare
|
||||
# (griglia e percorsi ridotti); serve a non scoprire un errore di stampa dopo venti minuti.
|
||||
QUICK = "--quick" in sys.argv
|
||||
if QUICK:
|
||||
OFFSETS = OFFSETS[:2]
|
||||
PHASES = PHASES[:2]
|
||||
N_PATHS = 300
|
||||
N_PATHS_REP = 300
|
||||
|
||||
# --- numeri PUBBLICATI da riprodurre ----------------------------------------------------------
|
||||
PUB_2507 = { # r0725_prop_ladder, CLOSE-ONLY leva 1,00x
|
||||
"CONC-2SL": (0.00, 0.131, 0.556),
|
||||
"CONC-DIV": (5.70, 0.178, 0.334),
|
||||
"SPARSO": (0.00, 0.168, 0.660),
|
||||
"MISTO": (10.70, 0.207, 0.334),
|
||||
}
|
||||
PUB_COUPLED = "P(>=50/g) 5,6-6,5% a 0,75x, P(zero) 52% a 0,75x / 65% a 1,00x (25/07 sera)"
|
||||
PUB_GATEC = dict(p50g=0.026, pzero=0.403) # §37, W_A, funding dentro, mediana d'ancora
|
||||
|
||||
# --- costi di funding per sleeve, PUBBLICATI (§35/§37), a peso 1,0 ----------------------------
|
||||
FUND_PUB = {"TP01": 0.0210, "SKH01": 0.0232, "XS01": 0.0145}
|
||||
|
||||
TRIALS = 0
|
||||
T0 = time.time()
|
||||
|
||||
|
||||
def bump(n: int = 1) -> None:
|
||||
global TRIALS
|
||||
TRIALS += n
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "=" * 104)
|
||||
if t:
|
||||
print(" " + t)
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
def tick(lab: str) -> None:
|
||||
print(f" [{time.time() - T0:6.0f}s] {lab}")
|
||||
|
||||
|
||||
# ==================================================================================
|
||||
# LA MACCHINA: una scala di conti che gira PIU' POLITICHE sugli STESSI sorteggi
|
||||
# ==================================================================================
|
||||
|
||||
def ladder_multi(Rm: np.ndarray, Gm: np.ndarray, sel: np.ndarray, n_paths: int, lev: float,
|
||||
seed: int, deluck: float, refund: bool = False, deposit_eur: float = 0.0,
|
||||
start_eur: float = pl.START_EUR, block: int = 20,
|
||||
boot: np.ndarray | None = None,
|
||||
track: bool = False) -> dict:
|
||||
"""`r0725_prop_coupled.simulate` generalizzato a N politiche in una corsa sola.
|
||||
|
||||
Rm, Gm : (giorni, n_cfg) — ritorni di chiusura e gap (<=0) di ciascuna CONFIGURAZIONE.
|
||||
sel : (n_group, n_slot) — indice di configurazione per ogni slot di ogni politica.
|
||||
|
||||
I gruppi (= politiche) sono impilati sull'asse dei percorsi e ricevono **gli stessi indici
|
||||
di bootstrap e gli stessi sorteggi di morte-firm**: il confronto fra politiche e' appaiato
|
||||
per costruzione (stesso mondo, allocazione diversa).
|
||||
|
||||
Con n_group=1 e refund/deposit spenti consuma il flusso di numeri casuali NELLO STESSO
|
||||
ORDINE di `pc.simulate` -> deve essere BIT-EXACT (controllo §2).
|
||||
"""
|
||||
rng = np.random.default_rng(seed)
|
||||
L = len(Rm)
|
||||
n_grp, n_slot = sel.shape
|
||||
if boot is None:
|
||||
n_blocks = int(np.ceil(HDAYS / block))
|
||||
st = rng.integers(0, L - block, size=(n_paths, n_blocks))
|
||||
boot = (st[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :HDAYS]
|
||||
# morte-firm: un solo sorteggio (n_days, n_paths, n_firm) == n_days chiamate consecutive
|
||||
du = rng.random((HDAYS, n_paths, len(FIRMS)))
|
||||
|
||||
Rd = Rm - (1.0 - deluck) * Rm.mean(axis=0, keepdims=True)
|
||||
P = n_grp * n_paths
|
||||
SELP = np.repeat(sel, n_paths, axis=0) # (P, n_slot)
|
||||
rowsP = np.arange(P)[:, None]
|
||||
|
||||
cash = np.full(P, start_eur * EURUSD)
|
||||
phase = np.full((P, n_slot), -1, np.int8)
|
||||
eq = np.ones((P, n_slot))
|
||||
firm = np.full((P, n_slot), -1, np.int8)
|
||||
notional = np.zeros((P, n_slot))
|
||||
price_paid = np.zeros((P, n_slot))
|
||||
refunded = np.zeros((P, n_slot), bool)
|
||||
firm_alive = np.ones((P, len(FIRMS)), bool)
|
||||
cum_payout = np.zeros(P)
|
||||
spent = np.zeros(P)
|
||||
got_back = np.zeros(P)
|
||||
n_tickets = np.zeros(P, int)
|
||||
max_conc = np.zeros(P, int)
|
||||
max_open = np.zeros(P, int)
|
||||
ever2 = np.zeros(P, bool)
|
||||
ever_slot1 = np.zeros(P, bool) # lo slot 1 e' mai stato aperto? (= la politica conta)
|
||||
traj = np.zeros((HDAYS // 30, n_grp)) if track else None
|
||||
p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0)
|
||||
tick_sorted = [sorted(F["tickets"], key=lambda x: -x[0]) for F in FIRMS]
|
||||
|
||||
for t in range(HDAYS):
|
||||
died = np.tile(du[t], (n_grp, 1)) < p_death_day
|
||||
newly = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm == fi) & kill[:, None]
|
||||
phase[hit] = -1
|
||||
notional[hit] = 0.0
|
||||
|
||||
if (cash >= MIN_PRICE).any():
|
||||
for k in range(n_slot):
|
||||
free = phase[:, k] == -1
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
used = np.where(firm == fi, notional, 0.0).sum(axis=1)
|
||||
for (size, price) in tick_sorted[fi]:
|
||||
buy = (free & firm_alive[:, fi] & (cash >= price)
|
||||
& (used + size <= F["cap"]))
|
||||
if not buy.any():
|
||||
continue
|
||||
cash[buy] -= price
|
||||
spent[buy] += price
|
||||
n_tickets[buy] += 1
|
||||
phase[buy, k] = 0
|
||||
eq[buy, k] = 1.0
|
||||
firm[buy, k] = fi
|
||||
notional[buy, k] = size
|
||||
price_paid[buy, k] = price
|
||||
refunded[buy, k] = False
|
||||
if k >= 1:
|
||||
ever_slot1 |= buy
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
rd = Rd[boot[:, t], :] # (n_paths, n_cfg)
|
||||
gd = Gm[boot[:, t], :]
|
||||
rdP = np.tile(rd, (n_grp, 1))
|
||||
gdP = np.tile(gd, (n_grp, 1))
|
||||
r = rdP[rowsP, SELP] * lev
|
||||
g = gdP[rowsP, SELP] * lev
|
||||
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
|
||||
for fi, F in enumerate(FIRMS):
|
||||
s_ = act & (firm == fi)
|
||||
if not s_.any():
|
||||
continue
|
||||
ev_t, ev_dd, ev_dl = F["ev"]
|
||||
fu_ml, fu_dl = F["fu"]
|
||||
in_ev = s_ & (phase == 0)
|
||||
in_fu = s_ & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl)))
|
||||
| (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl))))
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + ev_t) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
|
||||
nfu = (phase == 1).sum(axis=1)
|
||||
max_conc = np.maximum(max_conc, nfu)
|
||||
max_open = np.maximum(max_open, (phase >= 0).sum(axis=1))
|
||||
ever2 |= nfu >= 2
|
||||
|
||||
if (t + 1) % 30 == 0:
|
||||
fu = phase == 1
|
||||
gain = np.where(fu & (eq > 1.0), (eq - 1.0) * notional, 0.0)
|
||||
net = gain.sum(axis=1) * SPLIT * (1.0 - TAX_RATE)
|
||||
cum_payout += net
|
||||
cash += net
|
||||
pay = fu & (eq > 1.0)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund:
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
if deposit_eur:
|
||||
cash += deposit_eur * EURUSD
|
||||
if track:
|
||||
traj[(t + 1) // 30 - 1] = nfu.reshape(n_grp, n_paths).mean(axis=1)
|
||||
|
||||
out = []
|
||||
for gi in range(n_grp):
|
||||
s = slice(gi * n_paths, (gi + 1) * n_paths)
|
||||
ed = cum_payout[s] / EURUSD / (HDAYS / 365.0) / 365.0
|
||||
out.append(dict(eur_day=ed, med=float(np.median(ed)),
|
||||
p10=float(np.percentile(ed, 10)), p90=float(np.percentile(ed, 90)),
|
||||
mean=float(ed.mean()),
|
||||
p_ge10=float((ed >= 10.0).mean()),
|
||||
p_target=float((ed >= TARGET).mean()),
|
||||
p_zero=float((cum_payout[s] <= 0).mean()),
|
||||
n_tickets=float(n_tickets[s].mean()),
|
||||
max_conc=float(max_conc[s].mean()),
|
||||
max_open=float(max_open[s].mean()),
|
||||
p_ever2=float(ever2[s].mean()),
|
||||
p_slot1=float(ever_slot1[s].mean()),
|
||||
med_cash=float(np.median(cash[s])),
|
||||
mean_back=float(got_back[s].mean()),
|
||||
spent=float(spent[s].mean())))
|
||||
bump(n_grp)
|
||||
return dict(groups=out, traj=traj)
|
||||
|
||||
|
||||
# ==================================================================================
|
||||
# POLITICHE
|
||||
# ==================================================================================
|
||||
W_2SL = {"TP01": 0.75, "SKH01": 0.25}
|
||||
W_DIV = {"TP01": 0.55, "SKH01": 0.20, "XS01": 0.25}
|
||||
W_A = {"TP01": 0.38, "SKH01": 0.38, "XS01": 0.25}
|
||||
W_TP = {"TP01": 1.0}
|
||||
W_SKH = {"SKH01": 1.0}
|
||||
W_XS = {"XS01": 1.0}
|
||||
CFGS = [W_2SL, W_DIV, W_A, W_TP, W_SKH, W_XS] # indici 0..5
|
||||
I2SL, IDIV, IA, ITP, ISKH, IXS = range(6)
|
||||
|
||||
POLICIES = {
|
||||
"CONC-2SL ogni conto = book live": [I2SL] * MAXC,
|
||||
"CONC-DIV ogni conto = diversif.": [IDIV] * MAXC,
|
||||
"SPARSO 1 sleeve per conto": [ITP, IXS, ISKH, ITP, IXS, ISKH],
|
||||
"MISTO meta' div / meta' single": [IDIV, IXS, IDIV, ITP, IDIV, IXS],
|
||||
"CONC-A ogni conto = W_A 38/38/25": [IA] * MAXC,
|
||||
"MISTO-A MISTO col nucleo W_A": [IA, IXS, IA, ITP, IA, IXS],
|
||||
}
|
||||
PNAMES = list(POLICIES)
|
||||
SEL = np.array([POLICIES[p] for p in PNAMES], dtype=int)
|
||||
SHORT = [p.split()[0] for p in PNAMES]
|
||||
|
||||
|
||||
def _tab(rows: list[tuple], head: tuple) -> None:
|
||||
print(" " + " ".join(f"{h:>{w}}" for h, w in head))
|
||||
for r in rows:
|
||||
print(" " + " ".join(f"{v:>{w}}" for v, (_h, w) in zip(r, head)))
|
||||
|
||||
|
||||
# ==================================================================================
|
||||
def main() -> None:
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
print("=" * 104)
|
||||
print(" §60 LADDER-REDO — la politica multi-conto e' ancora MISTO?")
|
||||
print("=" * 104)
|
||||
print(" ATTESE REGISTRATE (dal docstring, prima di misurare):")
|
||||
print(" A1 l'ORDINE del 25/07 si replica, i LIVELLI no (+4 settimane di feed).")
|
||||
print(" A2 il FUNDING non ribalta l'ordine e semmai lo rafforza (MISTO paga MENO:")
|
||||
print(" 1,82%/a contro 2,16% di CONC-2SL; spread 0,33pp = un sesto del costo).")
|
||||
print(" A3 se l'ordine cambia, cambia per l'UNIVERSO XS01 e CONTRO MISTO/SPARSO.")
|
||||
print(" A4 con $654 si compra UN conto: la politica quasi non conta senza versamenti.")
|
||||
print(" A5 il deposito rimborsabile vale piu' sulla SCALA che sull'EV (+1-3pp).")
|
||||
|
||||
# ============================================================ §1 REPLICA 25/07
|
||||
hr("§1. REPLICA — i numeri pubblicati il 25/07, rigirati oggi con la stessa macchina")
|
||||
M, names = pl.sleeve_panel()
|
||||
print(f" pannello `pl.sleeve_panel()`: {len(M)} giorni, sleeve {names}, de-luck x{DELUCK_OLD}")
|
||||
pols_old = pl.policies(names)
|
||||
rows = []
|
||||
got = {}
|
||||
for pname, slots in pols_old.items():
|
||||
key = pname.split()[0]
|
||||
r = pl.simulate(M, slots, n_paths=N_PATHS_REP, lev=1.0, seed=SEED, intraday=False)
|
||||
got[key] = (r["med"], r["p_target"], r["p_zero"])
|
||||
pmed, pp50, ppz = PUB_2507[key]
|
||||
rows.append((key, f"{r['med']:.2f}", f"{pmed:.2f}",
|
||||
f"{r['p_target']:.1%}", f"{pp50:.1%}",
|
||||
f"{r['p_zero']:.1%}", f"{ppz:.1%}"))
|
||||
bump()
|
||||
_tab(rows, (("politica", 9), ("EUR/g oggi", 11), ("PUB", 6),
|
||||
("P>=50 oggi", 11), ("PUB", 6), ("P0 oggi", 8), ("PUB", 6)))
|
||||
ord_now = sorted(got, key=lambda k: -got[k][1])
|
||||
ord_pub = sorted(PUB_2507, key=lambda k: -PUB_2507[k][1])
|
||||
same = ord_now == ord_pub
|
||||
print(f"\n ordine su P(>=50/g) oggi: {' > '.join(ord_now)}")
|
||||
print(f" ordine su P(>=50/g) 25/07: {' > '.join(ord_pub)}")
|
||||
print(f" >>> ORDINE {'REPLICATO' if same else 'NON replicato'}; livelli "
|
||||
f"{'piu bassi' if np.mean([got[k][1] for k in got]) < np.mean([PUB_2507[k][1] for k in PUB_2507]) else 'piu alti'}"
|
||||
f" (media P(>=50/g) {np.mean([got[k][1] for k in got]):.1%} contro "
|
||||
f"{np.mean([PUB_2507[k][1] for k in PUB_2507]):.1%}).")
|
||||
print(" A1 " + ("CONFERMATA" if same else "REFUTATA") +
|
||||
" — `pl.sleeve_panel` ri-deriva le serie dal feed CORRENTE (stessa causa del -11%")
|
||||
print(" che §37 misuro' su `r0725_hyro`): la macchina e' quella, il vintage no.")
|
||||
tick("§1")
|
||||
|
||||
# ============================================================ §2 CONTROLLI
|
||||
hr("§2. CONTROLLI — bit-exact contro `pc.simulate`, e un controllo POSITIVO")
|
||||
cfgs_pc = [(0.75, 0.25, 0.0), (0.55, 0.20, 0.25), (1.0, 0.0, 0.0),
|
||||
(0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
|
||||
START_OLD = "2024-01-01"
|
||||
mats = [pc.book_tuples(*c, start=START_OLD) for c in cfgs_pc]
|
||||
Lc = min(len(m[0]) for m in mats)
|
||||
Rc = np.stack([m[0][-Lc:] for m in mats], axis=1)
|
||||
Gc = np.stack([m[1][-Lc:] for m in mats], axis=1)
|
||||
pc.DELUCK = DELUCK_OLD
|
||||
slots_conc = [0] * MAXC
|
||||
ref = pc.simulate(cfgs_pc, slots_conc, n_paths=800, lev=1.0, seed=99,
|
||||
lens="coupled", start=START_OLD)
|
||||
mine = ladder_multi(Rc, Gc, np.array([slots_conc]), n_paths=800, lev=1.0, seed=99,
|
||||
deluck=DELUCK_OLD)["groups"][0]
|
||||
d = float(np.abs(np.sort(ref["eur_day"]) - np.sort(mine["eur_day"])).max())
|
||||
d2 = float(np.abs(ref["eur_day"] - mine["eur_day"]).max())
|
||||
print(f" ladder_multi (1 gruppo) vs pc.simulate, lente accoppiata, 800 percorsi:")
|
||||
print(f" max|diff| percorso-per-percorso = {d2:.3e} (ordinati: {d:.3e})")
|
||||
print(f" -> {'BIT-EXACT' if d2 == 0.0 else 'DIVERGENTE'}")
|
||||
# controllo positivo: una politica volutamente rotta (leva 3x = busta subito) deve finire ultima
|
||||
selpos = np.array([slots_conc, slots_conc])
|
||||
rp = ladder_multi(Rc, Gc, selpos, n_paths=800, lev=1.0, seed=99, deluck=DELUCK_OLD)
|
||||
rbad = ladder_multi(Rc, Gc, np.array([slots_conc]), n_paths=800, lev=3.0, seed=99,
|
||||
deluck=DELUCK_OLD)["groups"][0]
|
||||
ok_pos = rbad["p_target"] < rp["groups"][0]["p_target"]
|
||||
print(f" controllo POSITIVO — la stessa politica a leva 3,00x (deve bustare):")
|
||||
print(f" P(>=50/g) 1,00x {rp['groups'][0]['p_target']:.1%} vs 3,00x {rbad['p_target']:.1%}"
|
||||
f" -> {'il confronto ha POTENZA' if ok_pos else '!! NESSUNA POTENZA'}")
|
||||
print(f" controllo di pairing — due gruppi identici devono dare lo stesso vettore: "
|
||||
f"max|diff| {np.abs(rp['groups'][0]['eur_day'] - rp['groups'][1]['eur_day']).max():.3e}")
|
||||
tick("§2")
|
||||
|
||||
# ============================================================ §3 pannello corretto
|
||||
hr("§3. IL PANNELLO CORRETTO — U13 Binance fuori campione, W-LONG 2021+, funding")
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13, h13, l13 = (Ob.reindex(p13.index)[X.U13], Hb.reindex(p13.index)[X.U13],
|
||||
Lb.reindex(p13.index)[X.U13])
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES}
|
||||
bump(len(PHASES))
|
||||
xs0 = XSP[PHASES[0]]
|
||||
cry_idx = pc.crypto_daily_tuples(1.0, 0.0).index
|
||||
base = cry_idx.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
S_LONG = max(first13, pd.Timestamp("2021-01-01", tz="UTC"))
|
||||
I = base[base >= S_LONG]
|
||||
print(f" W-LONG: {len(I)} giorni {I[0].date()} -> {I[-1].date()} | "
|
||||
f"XS01 = U13 Binance ({len(X.U13)} gambe) | de-luck x{DELUCK_NEW}")
|
||||
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
print(" !! cache funding assente: il filone NON puo' rispondere alla domanda (c). STOP.")
|
||||
return
|
||||
xsf = GC.xs_funding_measure(verbose=False)
|
||||
xs_ann = xsf["ann"]
|
||||
print(f" funding: TP01/SKH01 da serie misurate; XS01 = {xs_ann*100:+.2f}%/anno costante "
|
||||
f"(§37, IC95 [{(xs_ann-1.96*xsf['se'])*100:+.2f}, {(xs_ann+1.96*xsf['se'])*100:+.2f}])")
|
||||
|
||||
boot = PA.boot_idx(len(I), HDAYS, N_PATHS, seed=SEED)
|
||||
|
||||
def build_on(idx: pd.DatetimeIndex, xs: pd.DataFrame, off: int,
|
||||
fund: bool) -> tuple[np.ndarray, np.ndarray]:
|
||||
"""(R, gap) di TUTTE le configurazioni su un indice e una serie XS01 dati."""
|
||||
R = np.zeros((len(idx), len(CFGS)))
|
||||
G = np.zeros((len(idx), len(CFGS)))
|
||||
for ci, w in enumerate(CFGS):
|
||||
r, g = AP.rg_off(w, idx, xs, off)
|
||||
if fund:
|
||||
r = r - GC.fvec_for(w, idx, rate, off, xs_ann)
|
||||
R[:, ci], G[:, ci] = r, g
|
||||
return R, G
|
||||
|
||||
def build(off: int, ph: int, fund: bool) -> tuple[np.ndarray, np.ndarray]:
|
||||
return build_on(I, XSP[ph], off, fund)
|
||||
|
||||
# costo di funding EFFETTIVO per configurazione (verifica di A2)
|
||||
print(f"\n costo di funding per configurazione (%/anno di equity a leva 1,00x, off 0):")
|
||||
fcost = {}
|
||||
for ci, w in enumerate(CFGS):
|
||||
fv = GC.fvec_for(w, I, rate, 0, xs_ann)
|
||||
fcost[ci] = float(np.mean(fv)) * 365 * 100
|
||||
nm = ["book_2SL", "book_DIV", "W_A", "TP01 solo", "SKH01 solo", "XS01 solo"]
|
||||
for ci in range(len(CFGS)):
|
||||
pred = sum(FUND_PUB[k] * v for k, v in CFGS[ci].items()) * 100
|
||||
print(f" {nm[ci]:<11} misurato {fcost[ci]:>5.2f}%/a atteso da §35/§37 {pred:>5.2f}%/a")
|
||||
# CONTROLLO: il reindex su I non deve mangiare barre in silenzio (un NaN->0 e' un costo
|
||||
# sottostimato che nessun numero segnala).
|
||||
cov_tp = float(GC.f_tp01_sleeve(rate).reindex(I).notna().mean())
|
||||
cov_sk = float(GC.f_skh_sleeve(rate, 0).reindex(I).notna().mean())
|
||||
print(f" CONTROLLO di copertura su W-LONG: TP01 {cov_tp:.1%} delle barre, SKH01 {cov_sk:.1%}"
|
||||
f" -> {'ok' if min(cov_tp, cov_sk) > 0.99 else '!! IL REINDEX MANGIA BARRE'}")
|
||||
print(" ⚠ I costi misurati sono PIU' BASSI degli attesi, e non e' un disaccordo: §35 pubblica")
|
||||
print(" -2,16%/a sul 2019+, -1,39% sul 2022-03+ e -0,55% sul 2025+ (il costo SCENDE nel")
|
||||
print(" tempo) e questa finestra parte nel 2021. Costo del libro 75/25, anno per anno:")
|
||||
fser = pd.Series(GC.fvec_for(W_2SL, I, rate, 0, xs_ann), index=I)
|
||||
print(" " + " ".join(f"{y}:{float(g.mean()*365)*100:.2f}%"
|
||||
for y, g in fser.groupby(fser.index.year)))
|
||||
print(f" 🚨 Su tutta la storia oraria SKH01 paga -2,32% e TP01 -2,10% (§35). Su W-LONG sono")
|
||||
print(f" {fcost[ISKH]:.2f}% e {fcost[ITP]:.2f}%: **il verso del confronto TP01-vs-SKH01 sul")
|
||||
print(f" funding si INVERTE cambiando finestra** — l'aritmetica con cui avevo derivato A2")
|
||||
print(f" usava i numeri di storia piena, quindi la previsione va verificata, non dedotta.")
|
||||
print(f" costo di funding per POLITICA (media sugli slot):")
|
||||
polfund = {}
|
||||
for pi, p in enumerate(PNAMES):
|
||||
v = float(np.mean([fcost[c] for c in SEL[pi]]))
|
||||
polfund[SHORT[pi]] = v
|
||||
print(f" {SHORT[pi]:<9} {v:>5.2f}%/a")
|
||||
tick("§3")
|
||||
|
||||
# ============================================================ §4 decomposizione
|
||||
hr("§4. DECOMPOSIZIONE — un grado di liberta' per volta (ancora 0, fase 0, leva 1,00x)")
|
||||
print(" Senza questa tabella si sa che il numero e' cambiato, non QUALE correzione lo cambia.")
|
||||
# gli indici di CFGS non sono quelli di cfgs_pc: si rimappa (le prime 4 politiche sono
|
||||
# le uniche del 25/07; CONC-A e MISTO-A non esistevano e compaiono solo dal passo S3).
|
||||
map_pc = {I2SL: 0, IDIV: 1, ITP: 2, ISKH: 3, IXS: 4}
|
||||
sel4_pc = np.array([[map_pc[c] for c in POLICIES[p]] for p in PNAMES[:4]])
|
||||
bpc = PA.boot_idx(Lc, HDAYS, N_PATHS, seed=SEED)
|
||||
s0 = ladder_multi(Rc, np.zeros_like(Gc), sel4_pc, N_PATHS, 1.0, SEED, DELUCK_OLD, boot=bpc)
|
||||
s1 = ladder_multi(Rc, Gc, sel4_pc, N_PATHS, 1.0, SEED, DELUCK_OLD, boot=bpc)
|
||||
s2 = ladder_multi(Rc, Gc, sel4_pc, N_PATHS, 1.0, SEED, DELUCK_NEW, boot=bpc)
|
||||
# --- S2b/S3a: UNIVERSO e FINESTRA separati, sullo STESSO indice comune (crypto n HL n Bin).
|
||||
XS_HL = pc.xsec_daily_tuples("shared")
|
||||
I24 = I[I >= pd.Timestamp("2024-01-01", tz="UTC")].intersection(XS_HL.index)
|
||||
b24 = PA.boot_idx(len(I24), HDAYS, N_PATHS, seed=SEED)
|
||||
R2b, G2b = build_on(I24, XS_HL, 0, False)
|
||||
Rchk, Gchk, Ichk = pc.book_tuples(0.55, 0.20, 0.25, start="2024-01-01")
|
||||
kk = pd.DatetimeIndex(Ichk).isin(I24)
|
||||
jj = pd.DatetimeIndex(I24).isin(pd.DatetimeIndex(Ichk))
|
||||
dchk = float(np.abs(Rchk[kk] - R2b[:, IDIV][jj]).max())
|
||||
print(f" CONTROLLO: `rg_off` con le tuple HL riproduce `pc.book_tuples` (book_div) su "
|
||||
f"{int(kk.sum())} giorni a max|diff| = {dchk:.3e}")
|
||||
s2b = ladder_multi(R2b, G2b, SEL[:4], N_PATHS, 1.0, SEED, DELUCK_NEW, boot=b24)
|
||||
R3a, G3a = build_on(I24, XSP[PHASES[0]], 0, False)
|
||||
s3a = ladder_multi(R3a, G3a, SEL[:4], N_PATHS, 1.0, SEED, DELUCK_NEW, boot=b24)
|
||||
R3, G3 = build(0, PHASES[0], False)
|
||||
s3 = ladder_multi(R3, G3, SEL[:4], N_PATHS, 1.0, SEED, DELUCK_NEW, boot=boot)
|
||||
R4, G4 = build(0, PHASES[0], True)
|
||||
s4 = ladder_multi(R4, G4, SEL[:4], N_PATHS, 1.0, SEED, DELUCK_NEW, boot=boot)
|
||||
lab = ["S0 25/07 tale e quale (HL19 2024+, close-only, x0,60)",
|
||||
"S1 + lente ACCOPPIATA (misurata il 25/07 SERA)",
|
||||
"S2 + de-luck x0,89 invece di x0,60 (26/07)",
|
||||
"S2b [= S2 su indice comune: controllo di macchina]",
|
||||
"S3a + UNIVERSO: XS01 = U13 Binance, stessa finestra",
|
||||
"S3b + FINESTRA: W-LONG 2021+ (fuori campione)",
|
||||
"S4 + FUNDING = la lente onesta di oggi"]
|
||||
ALL = (s0, s1, s2, s2b, s3a, s3, s4)
|
||||
print(f"\n P(>=50 EUR/g) per politica, {N_PATHS} percorsi, stessi sorteggi:")
|
||||
print(" " + f"{'passo':<52}" + "".join(f"{s:>10}" for s in SHORT[:4]) + f"{' ordine':<40}")
|
||||
for l, st in zip(lab, ALL):
|
||||
v = [g["p_target"] for g in st["groups"]]
|
||||
o = " > ".join([SHORT[i] for i in np.argsort(-np.array(v))])
|
||||
print(f" {l:<52}" + "".join(f"{x:>9.1%} " for x in v) + f" {o:<40}")
|
||||
print(f"\n EUR/g MEDIO per politica (la MEDIANA e' degenere: tabella sotto):")
|
||||
print(" " + f"{'passo':<52}" + "".join(f"{s:>10}" for s in SHORT[:4]))
|
||||
for l, st in zip(lab, ALL):
|
||||
print(f" {l:<52}" + "".join(f"{g['mean']:>9.2f} " for g in st["groups"]))
|
||||
print(f"\n EUR/g MEDIANA — il numero di TESTA del 25/07 era 'MISTO 10,70':")
|
||||
print(" " + f"{'passo':<52}" + "".join(f"{s:>10}" for s in SHORT[:4]))
|
||||
for l, st in zip(lab, ALL):
|
||||
print(f" {l:<52}" + "".join(f"{g['med']:>9.2f} " for g in st["groups"]))
|
||||
tick("§4")
|
||||
|
||||
# ============================================================ §5 banda d'ancora
|
||||
hr(f"§5. BANDA D'ANCORA — {len(OFFSETS)} offset x {len(PHASES)} fasi, "
|
||||
f"funding ON/OFF, {len(PNAMES)} politiche")
|
||||
print(f" offset (sottocampione uniforme DICHIARATO dei 23): {list(OFFSETS)}")
|
||||
print(f" fasi XS01: {list(PHASES)} (lo stesso sottocampione di §37)")
|
||||
print(f" leva {LEV_MAIN:.2f}x fissa e uguale per tutte (confronto appaiato); "
|
||||
f"{N_PATHS} percorsi condivisi.")
|
||||
cells = []
|
||||
REF: dict[str, np.ndarray] = {} # vettori per-percorso alla cella di riferimento
|
||||
for off in OFFSETS:
|
||||
for ph in PHASES:
|
||||
for fund in (False, True):
|
||||
R, G = build(off, ph, fund)
|
||||
res = ladder_multi(R, G, SEL, N_PATHS, LEV_MAIN, SEED, DELUCK_NEW, boot=boot)
|
||||
for pi, g in enumerate(res["groups"]):
|
||||
cells.append(dict(off=off, ph=ph, fund=fund, pol=SHORT[pi],
|
||||
p50=g["p_target"], pz=g["p_zero"], med=g["med"],
|
||||
p10g=g["p_ge10"], mean=g["mean"], ever2=g["p_ever2"],
|
||||
slot1=g["p_slot1"], ntix=g["n_tickets"],
|
||||
maxc=g["max_conc"]))
|
||||
if off == 0 and ph == PHASES[0] and fund:
|
||||
REF[SHORT[pi]] = g["eur_day"]
|
||||
tick(f"offset {off}")
|
||||
C = pd.DataFrame(cells)
|
||||
|
||||
for fund, flab in ((True, "CON funding (la lente onesta)"), (False, "SENZA funding")):
|
||||
s = C[C["fund"] == fund]
|
||||
print(f"\n --- {flab} — mediana sulle {len(OFFSETS)*len(PHASES)} celle d'ancora")
|
||||
print(f" {'politica':>10} {'P(>=50/g)':>10} {'banda ancora p10-p90':>22} {'P(zero)':>9} "
|
||||
f"{'EUR/g med':>10} {'EUR/g medio':>12} {'P(>=10/g)':>10} {'P(2o conto)':>12}")
|
||||
for p in SHORT:
|
||||
q = s[s["pol"] == p]
|
||||
print(f" {p:>10} {q['p50'].median():>10.2%} "
|
||||
f"[{np.percentile(q['p50'],10):>9.2%},{np.percentile(q['p50'],90):>9.2%}] "
|
||||
f"{q['pz'].median():>9.1%} {q['med'].median():>10.2f} "
|
||||
f"{q['mean'].median():>12.2f} {q['p10g'].median():>10.1%} "
|
||||
f"{q['slot1'].median():>12.1%}")
|
||||
print(" ordine per metrica (se le tre non concordano, la classifica e' un artefatto")
|
||||
print(" della metrica scelta, non un fatto):")
|
||||
for mkey, mlab in (("p50", "P(>=50/g)"), ("mean", "EUR/g medio"), ("p10g", "P(>=10/g)")):
|
||||
o = s.groupby("pol")[mkey].median().sort_values(ascending=False)
|
||||
print(f" {mlab:<12} {' > '.join(o.index)}")
|
||||
|
||||
# riproduzione di §37 (W_A = CONC-A, funding dentro)
|
||||
q = C[(C["fund"]) & (C["pol"] == "CONC-A")]
|
||||
print(f"\n RIPRODUZIONE §37 (CONC-A = W_A 38/38/25, funding dentro, mediana d'ancora):")
|
||||
print(f" P(>=50/g) {q['p50'].median():.1%} (PUB {PUB_GATEC['p50g']:.1%}) | "
|
||||
f"P(zero) {q['pz'].median():.1%} (PUB {PUB_GATEC['pzero']:.1%})")
|
||||
print(" ⚠ non e' identica per costruzione: §37 usa `best_lev` per configurazione e 23")
|
||||
print(" offset x 3 fasi; qui la leva e' FISSA a 1,00x per tutte le politiche (appaiato)")
|
||||
print(f" e gli offset sono {len(OFFSETS)}. L'ordine di grandezza e' il controllo.")
|
||||
|
||||
# differenze APPAIATE cella per cella
|
||||
print(f"\n DIFFERENZE APPAIATE cella per cella (mediana delle differenze, mai differenza")
|
||||
print(f" delle mediane), funding dentro. Riferimento = MISTO (il vincitore del 25/07):")
|
||||
sf = C[C["fund"]]
|
||||
piv = sf.pivot_table(index=["off", "ph"], columns="pol", values="p50")
|
||||
ncell = len(piv)
|
||||
print(f" {'politica':>10} {'d P(>=50/g) vs MISTO':>22} {'>0 su celle':>13} "
|
||||
f"{'p10':>8} {'p90':>8}")
|
||||
for p in SHORT:
|
||||
if p == "MISTO":
|
||||
continue
|
||||
d = piv[p] - piv["MISTO"]
|
||||
print(f" {p:>10} {d.median()*100:>21.2f}pp {int((d>0).sum()):>7}/{ncell:<5} "
|
||||
f"{np.percentile(d,10)*100:>7.2f}pp {np.percentile(d,90)*100:>7.2f}pp")
|
||||
# --- controllo di LEVA: l'ordine dipende dalla leva scelta?
|
||||
print(f"\n CONTROLLO DI LEVA — le stesse celle a {LEV_ALT:.2f}x (off 0, {len(PHASES)} fasi,")
|
||||
print(f" funding ON). Se l'ordine cambia con la leva, non e' una proprieta' della politica:")
|
||||
alt = []
|
||||
for ph in PHASES:
|
||||
R, G = build(0, ph, True)
|
||||
res = ladder_multi(R, G, SEL, N_PATHS, LEV_ALT, SEED, DELUCK_NEW, boot=boot)
|
||||
for pi, g in enumerate(res["groups"]):
|
||||
alt.append(dict(ph=ph, pol=SHORT[pi], p50=g["p_target"], pz=g["p_zero"],
|
||||
mean=g["mean"]))
|
||||
A = pd.DataFrame(alt)
|
||||
oa = A.groupby("pol")["p50"].median().sort_values(ascending=False)
|
||||
o1 = C[(C["fund"]) & (C["off"] == 0)].groupby("pol")["p50"].median().sort_values(ascending=False)
|
||||
print(f" {'politica':>10} {'P(>=50/g) @0,75x':>18} {'P(>=50/g) @1,00x':>18} {'P(zero) @0,75x':>16}")
|
||||
for p_ in SHORT:
|
||||
print(f" {p_:>10} {A[A['pol']==p_]['p50'].median():>17.2%} "
|
||||
f"{o1[p_]:>17.2%} {A[A['pol']==p_]['pz'].median():>15.1%}")
|
||||
print(f" ordine @0,75x: {' > '.join(oa.index)}")
|
||||
print(f" ordine @1,00x: {' > '.join(o1.index)}")
|
||||
print(f" -> {'STESSO ordine' if list(oa.index) == list(o1.index) else 'ORDINE DIVERSO: la leva conta'}")
|
||||
tick("§5")
|
||||
|
||||
# ============================================================ §6 la previsione sul funding
|
||||
hr("§6. LA PREVISIONE A2 SUL FUNDING, VERIFICATA (appaiata cella per cella)")
|
||||
pv = C.pivot_table(index=["off", "ph", "pol"], columns="fund", values="p50")
|
||||
pv = pv.reset_index()
|
||||
print(f" {'politica':>10} {'costo fund %/a':>15} {'d P(>=50/g)':>13} {'<0 su celle':>13} "
|
||||
f"{'d EUR/g med':>13}")
|
||||
dmed = {}
|
||||
for p in SHORT:
|
||||
q = pv[pv["pol"] == p]
|
||||
d = (q[True] - q[False]).values
|
||||
dmed[p] = float(np.median(d))
|
||||
pm = C.pivot_table(index=["off", "ph", "pol"], columns="fund", values="med").reset_index()
|
||||
qm = pm[pm["pol"] == p]
|
||||
dm = (qm[True] - qm[False]).values
|
||||
print(f" {p:>10} {polfund[p]:>14.2f}% {np.median(d)*100:>12.2f}pp "
|
||||
f"{int((d<0).sum()):>7}/{len(d):<5} {np.median(dm):>12.2f}")
|
||||
ordf_on = C[C["fund"]].groupby("pol")["p50"].median().sort_values(ascending=False).index.tolist()
|
||||
ordf_off = C[~C["fund"]].groupby("pol")["p50"].median().sort_values(ascending=False).index.tolist()
|
||||
a2 = ordf_on == ordf_off
|
||||
print(f"\n ordine SENZA funding: {' > '.join(ordf_off)}")
|
||||
print(f" ordine CON funding: {' > '.join(ordf_on)}")
|
||||
print(f" >>> A2 {'CONFERMATA' if a2 else 'REFUTATA'}: il funding "
|
||||
f"{'NON cambia' if a2 else 'CAMBIA'} l'ordine fra politiche.")
|
||||
cc = np.corrcoef([polfund[p] for p in SHORT], [dmed[p] for p in SHORT])[0, 1]
|
||||
print(f" correlazione (costo di funding della politica, danno misurato): {cc:+.2f} "
|
||||
f"[atteso negativo: chi paga di piu' perde di piu']")
|
||||
tick("§6")
|
||||
|
||||
# ============================================================ §7 numero di conti
|
||||
hr("§7. LA DIMENSIONE MAI TESTATA — il NUMERO DI CONTI non e' dato, si COMPRA")
|
||||
Rf, Gf = build(0, 0, True)
|
||||
scen = [("nessun versamento, quota persa", 0.0, False),
|
||||
("nessun versamento, quota RIMBORSATA (§30)", 0.0, True),
|
||||
("EUR 500/mese, quota persa", 500.0, False),
|
||||
("EUR 500/mese, quota RIMBORSATA", 500.0, True)]
|
||||
trajs = {}
|
||||
for lab_s, dep, ref_ in scen:
|
||||
res = ladder_multi(Rf, Gf, SEL, N_PATHS, LEV_MAIN, SEED, DELUCK_NEW,
|
||||
refund=ref_, deposit_eur=dep, boot=boot, track=True)
|
||||
trajs[lab_s] = res
|
||||
print(f"\n --- {lab_s}")
|
||||
print(f" {'politica':>10} {'biglietti':>10} {'max conti':>10} {'P(mai >=2)':>11} "
|
||||
f"{'P(>=50/g)':>10} {'EUR/g med':>10} {'P(zero)':>9} {'rimborso $':>11}")
|
||||
for pi, g in enumerate(res["groups"]):
|
||||
print(f" {SHORT[pi]:>10} {g['n_tickets']:>10.2f} {g['max_conc']:>10.2f} "
|
||||
f"{1-g['p_ever2']:>10.1%} {g['p_target']:>10.1%} {g['med']:>10.2f} "
|
||||
f"{g['p_zero']:>9.1%} {g['mean_back']:>11.0f}")
|
||||
print("\n TRAIETTORIA del numero MEDIO di conti funded vivi (mesi 6/12/18/24/30/36):")
|
||||
for lab_s in trajs:
|
||||
tr = trajs[lab_s]["traj"]
|
||||
print(f" {lab_s:<44}" + "".join(
|
||||
f"{tr[m-1].mean():>7.2f}" for m in (6, 12, 18, 24, 30, 36)))
|
||||
print("\n DISPERSIONE fra politiche (max-min di P(>=50/g)) per scenario — quanto CONTA")
|
||||
print(" la scelta della politica:")
|
||||
for lab_s in trajs:
|
||||
v = [g["p_target"] for g in trajs[lab_s]["groups"]]
|
||||
best = SHORT[int(np.argmax(v))]
|
||||
print(f" {lab_s:<44} spread {max(v)-min(v):>6.2%} vincitore {best}")
|
||||
tick("§7")
|
||||
|
||||
# ============================================================ §8 MDE e verdetto
|
||||
hr("§8. MDE — la finestra distingue davvero due politiche?")
|
||||
sf = C[C["fund"]]
|
||||
piv = sf.pivot_table(index=["off", "ph"], columns="pol", values="p50")
|
||||
print(" TRE risoluzioni, e sono cose DIVERSE. Confonderle e' il modo standard di trasformare")
|
||||
print(" rumore in classifica.")
|
||||
print(f"\n (a) MONTE CARLO appaiato, cella di riferimento (off 0, fase {PHASES[0]}, funding ON):")
|
||||
print(" i due esiti sono osservati sugli STESSI percorsi -> SE di McNemar sui discordanti.")
|
||||
print(f" {'coppia':>22} {'d P(>=50/g)':>13} {'discordanti':>12} {'SE':>8} {'z':>8}")
|
||||
base = REF["MISTO"] >= TARGET
|
||||
for p_ in SHORT:
|
||||
if p_ == "MISTO":
|
||||
continue
|
||||
oth = REF[p_] >= TARGET
|
||||
n01 = int((base & ~oth).sum())
|
||||
n10 = int((~base & oth).sum())
|
||||
d = float(base.mean() - oth.mean())
|
||||
se = float(np.sqrt(n01 + n10) / len(base)) if (n01 + n10) else float("nan")
|
||||
z = d / se if se and se > 0 else float("nan")
|
||||
print(f" {'MISTO - ' + p_:>22} {d*100:>+12.2f}pp {n01 + n10:>12} "
|
||||
f"{se*100:>7.2f}pp {z:>+8.2f}")
|
||||
print(" ⚠ e' la risoluzione della SIMULAZIONE, non dell'evidenza: dice se due politiche")
|
||||
print(" differiscono SU QUESTI percorsi, non se differirebbero nel mondo.")
|
||||
print(f"\n (b) BANDA D'ANCORA sulle {len(piv)} celle (mediana delle differenze APPAIATE).")
|
||||
print(" 🚨 NON e' un intervallo di confidenza e non ci si attacca un p-value (regola §57:")
|
||||
print(" le 24 ancore correlano 0,63 e valgono ~2 osservazioni indipendenti). Si legge come")
|
||||
print(" robustezza alla SCELTA dell'ancora, e basta:")
|
||||
print(f" {'coppia':>22} {'mediana':>11} {'p10':>11} {'p90':>11} {'segno tenuto':>14}")
|
||||
for p_ in SHORT:
|
||||
if p_ == "MISTO":
|
||||
continue
|
||||
d = (piv["MISTO"] - piv[p_]).values
|
||||
print(f" {'MISTO - ' + p_:>22} {np.median(d)*100:>+10.2f}pp "
|
||||
f"{np.percentile(d,10)*100:>+10.2f}pp {np.percentile(d,90)*100:>+10.2f}pp "
|
||||
f"{int((d>0).sum()):>6}/{len(d):<7}")
|
||||
yrs = len(I) / 365.25
|
||||
print(f"\n (c) DATO — l'unica che limita davvero. La finestra e' {yrs:.1f} anni e i {N_PATHS}")
|
||||
print(f" percorsi sono ricampionamenti degli STESSI {len(I)} giorni: il bootstrap non crea")
|
||||
print(f" informazione. MDE sul drift ~ 1,96/sqrt({yrs:.1f}) = {1.96/np.sqrt(yrs):.2f} di Sharpe.")
|
||||
print(" Il differenziale di FUNDING fra politiche misurato in §3 e' ~0,10pp/anno di drift:")
|
||||
print(" irrisorio rispetto all'MDE. Cio' che le politiche possono davvero separare non e'")
|
||||
print(" un differenziale di rendimento ma la GEOMETRIA — correlazione fra conti e")
|
||||
print(" barriera per-conto — e quella si misura sulla forma, non sul drift.")
|
||||
|
||||
hr("VERDETTO")
|
||||
fin = C[C["fund"]].groupby("pol")["p50"].median().sort_values(ascending=False)
|
||||
fin_med = C[C["fund"]].groupby("pol")["med"].median()
|
||||
fin_pz = C[C["fund"]].groupby("pol")["pz"].median()
|
||||
for p in fin.index:
|
||||
print(f" {p:>10} P(>=50/g) {fin[p]:>6.2%} EUR/g med {fin_med[p]:>6.2f} "
|
||||
f"P(zero) {fin_pz[p]:>6.1%}")
|
||||
win = fin.index[0]
|
||||
print(f"\n VINCITORE OGGI: {win} (25/07: MISTO)")
|
||||
print(f" celle valutate: {len(C)} righe = {len(OFFSETS)}x{len(PHASES)}x2x{len(PNAMES)}; "
|
||||
f"valutazioni MC totali contate al rialzo: {TRIALS}")
|
||||
print(f" tempo {time.time()-T0:.0f}s")
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,877 @@
|
||||
#!/usr/bin/env python
|
||||
"""r0823b_obiettivo_diretto — OTTIMIZZARE DIRETTAMENTE L'OBIETTIVO DEL PROGETTO (2026-08-23).
|
||||
|
||||
§58 dell'ondata. Libro, pesi, cron, config: NON TOCCATI (isolamento provato in §0).
|
||||
|
||||
IL BUCO
|
||||
-------
|
||||
Ogni ottimizzazione fatta in questo progetto ha massimizzato **un'altra cosa**:
|
||||
* lo **Sharpe** (ogni filone di ricerca direzionale);
|
||||
* **J = P(pass) x P(alive)** (PROP-ALLOC §17, PROP-RECAL §29, SKH-ANCHOR-PROP §32);
|
||||
* **E[payout]** (r0725_hyro, §37);
|
||||
* il **capitale mediano** o **P(arrivare al capitale-rendita)** (§36, r0807_piano_netto).
|
||||
E il critico di §37 ha scritto la frase che apre questo filone:
|
||||
«piu' leva sul funded ALZA E[payout] e ABBASSA P(payout): sono due obiettivi diversi».
|
||||
**Nessuno ha mai ottimizzato DIRETTAMENTE `P(reddito >= 50 EUR/giorno entro H)`**, che e'
|
||||
l'obiettivo DICHIARATO del progetto. I numeri operativi pubblicati (42% -> 7,8% -> 4,4% ->
|
||||
2,6%) sono tutti **letti alla cella che massimizza J**, non alla cella che massimizza P.
|
||||
|
||||
LE DUE DEFINIZIONI, DICHIARATE PRIMA DI MISURARE
|
||||
------------------------------------------------
|
||||
Il progetto ne usa DUE senza mai metterle sulla stessa pagina, e danno risposte opposte:
|
||||
|
||||
**A — RICCHEZZA (rendita sostenibile).** «reddito >= 50 EUR/g» = il patrimonio PROPRIO
|
||||
raggiunge il **capitale-rendita** (muro), cioe' il capitale da cui si preleva 50 EUR/g con
|
||||
P(capitale a 20 anni >= capitale iniziale) >= 90% (definizione 25/07, invariata). E' la
|
||||
definizione dei muri, delle traiettorie e di tutto il piano (§36). E' **sostenibile per
|
||||
costruzione**.
|
||||
|
||||
**B — FLUSSO (produzione realizzata).** «reddito >= 50 EUR/g» = la media dei payout incassati
|
||||
sull'orizzonte, `cum_payout / giorni`, >= 50 EUR/g. E' la definizione di `r0725_prop_ladder`
|
||||
e quindi di **ogni numero del canale funded** (§29 7,8% · §32 4,4% · §37 2,6%). **NON e'
|
||||
sostenibile**: un conto funded che busta il giorno dopo l'orizzonte azzera il flusso, e la
|
||||
stessa cassa che il contatore chiama «reddito» resta nel conto (nel simulatore ufficiale la
|
||||
cassa si accumula E conta come reddito: e' una PRODUZIONE, non un prelievo).
|
||||
|
||||
Qui si misurano **entrambe**, sullo stesso Monte Carlo e sugli stessi percorsi, e si riporta
|
||||
come cambia la risposta. Primaria = **A**, perche' e' quella su cui il progetto ha costruito il
|
||||
muro, i versamenti e la decisione di venue; B si riporta perche' e' quella dei numeri pubblicati.
|
||||
|
||||
LO SPAZIO DI POLITICA — dichiarato esaustivamente PRIMA di misurare
|
||||
--------------------------------------------------------------------
|
||||
1. `k` leva del libro proprio {1,00 · 1,25 · 1,50} (§38: la chiave NON esiste)
|
||||
2. `own` ripartizione del libro proprio {LIVE 75/25 · W_A 38/38/25}
|
||||
3. `lev_fu` leva del conto funded {0,50 · 0,75 · 1,00 · 1,25}
|
||||
4. `n_max` numero di conti concorrenti {0 · 1 · 3 · 6} (0 = nessun biglietto)
|
||||
5. `pref` taglia del biglietto {grande · piccolo}
|
||||
6. `rebuy` ri-comprare dopo un bust {si' · no}
|
||||
7. `floor` capitale proprio sotto cui NON si compra {$0 · $2.000 · $10.000}
|
||||
8. `dep` versamento mensile {EUR 0 · 250 · 500} (il piano in corso e' 500)
|
||||
9. `invest` la cassa lavora sul libro invece di restare ferma {si' · no}
|
||||
Il punto (9) e' un difetto misurabile della macchineria pubblicata: in `pl.simulate` /
|
||||
`pc.simulate` / `gate_c.ladder` **la cassa dei payout resta FERMA per 36 mesi**.
|
||||
|
||||
LE MIE ATTESE, REGISTRATE PRIMA DI MISURARE
|
||||
--------------------------------------------
|
||||
A1. L'argmax di P(>=50/g) sara' a leva **piu' alta** dell'argmax di J, e la differenza sara'
|
||||
grande (fattore >2 su P). *Motivo: P(>=50/g) e' una probabilita' di superare una soglia
|
||||
alta = coda destra; J e' una probabilita' di sopravvivenza = coda sinistra.*
|
||||
A2. Sotto la definizione **A** (ricchezza) il canale funded **non** portera' P(36 mesi) sopra
|
||||
zero in modo apprezzabile: il muro e' ~$313k e 36 mesi da $635 sono ~3 ordini di grandezza.
|
||||
Quindi la risposta alla domanda «esiste una politica sopra il 20% a 36 mesi?» sara'
|
||||
**SI' sotto B e NO sotto A**, e questa e' la vera risposta del filone.
|
||||
A3. Investire la cassa invece di lasciarla ferma valdra' poco su B (il flusso non dipende dalla
|
||||
cassa) e molto su A. *Se sbaglio e vale poco anche su A, lo dico.*
|
||||
A4. L'ottimo di P sara' accompagnato da P(rovina) molto alta (>50%) — cioe' sara' un ottimo che
|
||||
il progetto NON dovrebbe adottare, e va riportato come informazione, non come consiglio.
|
||||
A5. Il vincolo binding a 36 mesi non sara' ne' la leva ne' il numero di conti ma il **cap
|
||||
$200k/trader** oppure il **capitale che entra**. Mi aspetto il secondo.
|
||||
|
||||
CONVENZIONI
|
||||
-----------
|
||||
* Lente **ACCOPPIATA** ovunque ci sia una barriera a un giorno (regola 25/07, riconfermata §33).
|
||||
* Cella d'ancora **MEDIANA** (non la canonica, che sta al 91° pctl — §32), scelta con lo stesso
|
||||
criterio di `gate_c` su un sottoinsieme d'ancore dichiarato PRIMA.
|
||||
* Funding **DENTRO** (§35), de-luck **x0,89** sul drift (§ r0726_deluck_factor), fisco 33% +
|
||||
patrimoniale 0,2% sul libro proprio (§ r0807), morte-firm 10%/anno, cap $200k/trader.
|
||||
* Baseline del libro: **`hourly`** (la lente di ogni muro e traiettoria) — dichiarata perche' il
|
||||
critico di §57 ha misurato che sotto «75/25» convivono tre baseline diverse.
|
||||
* Muro: **CONGELATO** a k=1 come primaria (si de-leva al traguardo: la leva non deve poter
|
||||
spostare il bersaglio); **MOBILE** come sensibilita' (§53 dichiara che la differenza vale 1,2
|
||||
anni). Banda del muro propagata dai valori di §57.
|
||||
* Monte Carlo: la risoluzione si dichiara. 1500 percorsi -> SE ~1,0pp su una P vicina al 20%.
|
||||
|
||||
Uso: nice -n 19 timeout 900 uv run python scripts/research/r0823b_obiettivo_diretto.py
|
||||
... --fast (griglia ridotta, ~1/3 del tempo)
|
||||
Rete: NESSUNA (solo cache su disco: parquet certificati, cache Binance di §21, cache funding
|
||||
di §35). Nessuna scrittura fuori da stdout.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv: # r0822d_funding legge USE_NET all'import
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_capcurve as CC # noqa: E402 TAX_RATE, EURUSD, book_series
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm, scala di conti
|
||||
import r0727_tasse as TX # noqa: E402 PATRIMONIALE, CARRY_ANNI
|
||||
import r0807_piano_netto as PN # noqa: E402 passo_fiscale, accumula, muro
|
||||
import r0822_prop_alloc as PA # noqa: E402 boot_idx, DELUCK
|
||||
import r0822b_prop_recal as PR # noqa: E402 obj_rg, LEVS, pannelli Binance
|
||||
import r0822b_xs01_oos as X # noqa: E402 U13, motore XS01
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 rg_off (offset di SKH01)
|
||||
import r0822d_funding as FD # noqa: E402 il funding
|
||||
import r0822d_gate_c as GC # noqa: E402 ladder, fvec_for, xs_funding
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
FAST = "--fast" in sys.argv
|
||||
EURUSD = pl.EURUSD
|
||||
TAX = CC.TAX_RATE
|
||||
PATR = TX.PATRIMONIALE
|
||||
DELUCK = PA.DELUCK # x0,89 misurato
|
||||
W_LIVE = {"TP01": 0.75, "SKH01": 0.25}
|
||||
W_A = {"TP01": 0.38, "SKH01": 0.38, "XS01": 0.25}
|
||||
START_USD = 635.0 # il conto Deribit VERO di oggi
|
||||
SEED_LAD = pl.HORIZON_MONTHS * 0 + 20260822 # lo stesso di gate_c (per la bit-exactness)
|
||||
SEED_BOOT = 58023
|
||||
N_PATHS = 900 if FAST else 1500
|
||||
N_PATHS_J = PA.N_PATHS
|
||||
MIN_PAYOUT = GC.MIN_PAYOUT_TRADER
|
||||
ORIZZONTI_M = (24, 36, 60, 120)
|
||||
H_MAX_D = max(ORIZZONTI_M) * 30
|
||||
MARKS = tuple(m * 30 for m in ORIZZONTI_M)
|
||||
OFFSETS_SUB = tuple(range(0, 690, 90)) if not FAST else (0, 180, 360, 540) # 8 (o 4) a priori
|
||||
PHASES_SUB = AP.PHASES_SUB # (0, 3, 7) — dichiarato da §32
|
||||
LEVS_FU = (0.50, 0.75, 1.00, 1.25)
|
||||
NMAX = (1, 3, 6)
|
||||
PREFS = ("grande", "piccolo")
|
||||
REBUY = (True, False)
|
||||
|
||||
# numeri PUBBLICATI da riprodurre PRIMA di produrne di nuovi
|
||||
PUB = dict(muro_L3=313_143.0, perp_L3=0.0635, drift_L3=0.1519,
|
||||
p50g_fund=0.026, p50g_p10=0.015, p50g_p90=0.047, pzero_fund=0.403,
|
||||
p50g_nofund=0.044,
|
||||
muro_p90=186_623.0, muro_m1se=709_753.0) # banda di §57
|
||||
|
||||
TRIALS = 0
|
||||
T0 = time.time()
|
||||
|
||||
|
||||
def bump(n: int = 1) -> None:
|
||||
global TRIALS
|
||||
TRIALS += n
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "=" * 104)
|
||||
if t:
|
||||
print(" " + t)
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
def tick(lab: str) -> None:
|
||||
print(f" [{time.time() - T0:6.0f}s] {lab}", flush=True)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# IL SIMULATORE UNIFICATO
|
||||
# ===========================================================================
|
||||
def uni(Ra: np.ndarray, Ga: np.ndarray, Rb: np.ndarray, boot: np.ndarray, *,
|
||||
lev_fu: float = 1.0, n_max: int = 6, pref: str = "grande", rebuy: bool = True,
|
||||
floor_usd: float = 0.0, k_book: float = 1.0, invest: bool = False,
|
||||
dep_eur: float = 0.0, start_usd: float = pl.START_EUR * EURUSD,
|
||||
seed: int = SEED_LAD, refund: bool = False, min_payout: float = 0.0,
|
||||
tax: float = 0.0, patr: float = 0.0, walls: tuple = (),
|
||||
marks: tuple = (), deposit_mode: str = "ladder",
|
||||
deluck_f: float = DELUCK) -> dict:
|
||||
"""UN simulatore per le DUE strade, sugli STESSI percorsi.
|
||||
|
||||
E' una GENERALIZZAZIONE STRETTA di `gate_c.ladder` (che a sua volta e' `pc.simulate` con
|
||||
tre aggiunte): con `n_max=6, pref='grande', rebuy=True, floor=0, k_book=0, invest=False,
|
||||
tax=0, patr=0, deposit_mode='ladder'` deve essere **BIT-EXACT** rispetto a `gate_c.ladder`.
|
||||
E con `n_max=0, invest=True, tax=0.33, patr=0.002, deposit_mode='accumula'` deve essere
|
||||
**BIT-EXACT** rispetto a `PN.accumula`. I due controlli sono in §1.
|
||||
|
||||
Cio' che aggiunge, e che nessuna macchina pubblicata ha:
|
||||
* un **pot proprio** che compone al libro (`k_book x Rb`) invece di restare fermo, col
|
||||
fisco d'accumulo dentro (stessa `PN.passo_fiscale` del piano);
|
||||
* i **payout che rientrano nel pot** e quindi compongono;
|
||||
* `floor_usd` — un capitale proprio sotto cui non si compra un altro biglietto;
|
||||
* `rebuy` — la scelta di NON ricomprare dopo un bust;
|
||||
* `pref` — biglietto piu' grande o piu' piccolo (piu' tentativi);
|
||||
* il **primo passaggio** al capitale-rendita, per l'obiettivo A.
|
||||
|
||||
`Ra/Ga` = libro del conto FUNDED (ritorno e gap intraday accoppiato), `Rb` = libro PROPRIO.
|
||||
Il de-luck si applica al DRIFT di R (non al gap): stessa convenzione di `ladder`.
|
||||
"""
|
||||
rng = np.random.default_rng(seed)
|
||||
n_paths, n_days = boot.shape
|
||||
Ram = np.asarray(Ra, float).copy()
|
||||
Ram = Ram - (1.0 - deluck_f) * Ram.mean()
|
||||
Gam = np.asarray(Ga, float)
|
||||
Rbm = np.asarray(Rb, float).copy()
|
||||
Rbm = Rbm - (1.0 - deluck_f) * Rbm.mean()
|
||||
|
||||
n_slot = int(n_max)
|
||||
FIRMS = pl.FIRMS
|
||||
cash = np.full(n_paths, float(start_usd))
|
||||
basis = cash.copy() # base fiscale del pot
|
||||
carry = np.zeros((n_paths, TX.CARRY_ANNI))
|
||||
anno_start = cash.copy()
|
||||
flusso = np.zeros(n_paths)
|
||||
cum_payout = np.zeros(n_paths)
|
||||
spent = np.zeros(n_paths)
|
||||
got_back = np.zeros(n_paths)
|
||||
deposited = np.zeros(n_paths)
|
||||
n_payouts = np.zeros(n_paths, int)
|
||||
n_tickets = np.zeros(n_paths, int)
|
||||
n_pass = np.zeros(n_paths, int)
|
||||
peak_notional = np.zeros(n_paths)
|
||||
|
||||
if n_slot:
|
||||
Rs_full = Ram[boot] * lev_fu # (paths, days) — tutti i conti uguali
|
||||
Gs_full = Gam[boot] * lev_fu
|
||||
phase = np.full((n_paths, n_slot), -1, np.int8)
|
||||
eq = np.ones((n_paths, n_slot))
|
||||
firm = np.full((n_paths, n_slot), -1, np.int8)
|
||||
notional = np.zeros((n_paths, n_slot))
|
||||
price_paid = np.zeros((n_paths, n_slot))
|
||||
refunded = np.zeros((n_paths, n_slot), bool)
|
||||
used = np.zeros((n_paths, n_slot), bool)
|
||||
firm_alive = np.ones((n_paths, len(FIRMS)), bool)
|
||||
p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0)
|
||||
Rbp = Rbm[boot] if (invest and k_book > 0) else None
|
||||
|
||||
hit = {w: np.full(n_paths, -1, int) for w in walls}
|
||||
snap: dict[int, dict] = {}
|
||||
fiscale = (tax > 0 or patr > 0)
|
||||
|
||||
for t in range(n_days):
|
||||
# ---- morte di una firm (identico a ladder: il draw avviene SEMPRE, anche a 0 slot,
|
||||
# solo se il canale funded esiste)
|
||||
if n_slot:
|
||||
died = rng.random((n_paths, len(FIRMS))) < p_death_day
|
||||
newly_dead = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly_dead.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly_dead[:, fi]
|
||||
if kill.any():
|
||||
h = (firm == fi) & kill[:, None]
|
||||
phase[h] = -1
|
||||
notional[h] = 0.0
|
||||
|
||||
# ---- acquisto biglietti
|
||||
for k in range(n_slot):
|
||||
free = phase[:, k] == -1
|
||||
if not rebuy:
|
||||
free &= ~used[:, k]
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
u = np.where(firm == fi, notional, 0.0).sum(axis=1)
|
||||
order = sorted(F["tickets"], key=(lambda x: -x[0]) if pref == "grande"
|
||||
else (lambda x: x[0]))
|
||||
for (size, price) in order:
|
||||
buy = (free & firm_alive[:, fi] & (cash >= price)
|
||||
& (cash - price >= floor_usd) & (u + size <= F["cap"]))
|
||||
if not buy.any():
|
||||
continue
|
||||
cash[buy] -= price
|
||||
flusso[buy] -= price
|
||||
spent[buy] += price
|
||||
n_tickets[buy] += 1
|
||||
phase[buy, k] = 0
|
||||
eq[buy, k] = 1.0
|
||||
firm[buy, k] = fi
|
||||
notional[buy, k] = size
|
||||
price_paid[buy, k] = price
|
||||
refunded[buy, k] = False
|
||||
used[buy, k] = True
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
# ---- dinamica dei conti
|
||||
r = Rs_full[:, t][:, None]
|
||||
g = Gs_full[:, t][:, None]
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
for fi, F in enumerate(FIRMS):
|
||||
s_ = act & (firm == fi)
|
||||
if not s_.any():
|
||||
continue
|
||||
ev_t, ev_dd, ev_dl = F["ev"]
|
||||
fu_ml, fu_dl = F["fu"]
|
||||
in_ev = s_ & (phase == 0)
|
||||
in_fu = s_ & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl)))
|
||||
| (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl))))
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + ev_t) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
n_pass += passed.sum(axis=1)
|
||||
peak_notional = np.maximum(peak_notional,
|
||||
np.where(phase == 1, notional, 0.0).sum(axis=1))
|
||||
|
||||
# ---- il POT proprio compone
|
||||
if Rbp is not None:
|
||||
cash = cash * (1.0 + k_book * Rbp[:, t])
|
||||
|
||||
# ---- versamento (convenzione `accumula`: giorno 30, 60, ...)
|
||||
if deposit_mode == "accumula" and dep_eur and t % 30 == 0 and t > 0:
|
||||
cash += dep_eur * EURUSD
|
||||
flusso += dep_eur * EURUSD
|
||||
deposited += dep_eur * EURUSD
|
||||
|
||||
# ---- payout mensile + rimborso + versamento (convenzione `ladder`)
|
||||
if (t + 1) % 30 == 0:
|
||||
if n_slot:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * pl.SPLIT) >= min_payout)
|
||||
gain = np.where(pay, (eq - 1.0) * notional, 0.0)
|
||||
net = gain.sum(axis=1) * pl.SPLIT * (1.0 - TAX)
|
||||
cum_payout += net
|
||||
cash += net
|
||||
flusso += net
|
||||
n_payouts += (pay.sum(axis=1) > 0).astype(int)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund:
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
flusso += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
if deposit_mode == "ladder" and dep_eur:
|
||||
cash += dep_eur * EURUSD
|
||||
flusso += dep_eur * EURUSD
|
||||
deposited += dep_eur * EURUSD
|
||||
|
||||
# ---- primo passaggio al muro (obiettivo A)
|
||||
for w, arr in hit.items():
|
||||
nuovi = (arr < 0) & (cash >= w)
|
||||
arr[nuovi] = t
|
||||
|
||||
# ---- fisco d'accumulo sul pot
|
||||
if fiscale and (t + 1) % 365 == 0:
|
||||
PN.passo_fiscale(cash, anno_start, flusso, carry, tax, patr)
|
||||
anno_start = cash.copy()
|
||||
flusso[:] = 0.0
|
||||
basis = cash.copy()
|
||||
|
||||
if (t + 1) in marks:
|
||||
d = t + 1
|
||||
ed = cum_payout / EURUSD / (d / 365.0) / 365.0
|
||||
contrib = float(start_usd) + deposited
|
||||
snap[d] = dict(p_flow=float((ed >= pl.TARGET_EUR_DAY).mean()),
|
||||
p_flow10=float((ed >= 10.0).mean()),
|
||||
med_eur=float(np.median(ed)),
|
||||
med_cash=float(np.median(cash)),
|
||||
mean_cash=float(cash.mean()),
|
||||
p10_cash=float(np.percentile(cash, 10)),
|
||||
p_zero=float((cum_payout <= 0).mean()),
|
||||
p_sotto=float((cash < contrib).mean()),
|
||||
p_rovina=float((cash < 0.10 * contrib).mean()),
|
||||
contrib=float(contrib.mean() if np.ndim(contrib) else contrib),
|
||||
**{f"A{w:.0f}": float(((hit[w] >= 0) & (hit[w] < d)).mean())
|
||||
for w in walls})
|
||||
|
||||
ed = cum_payout / EURUSD / (n_days / 365.0) / 365.0
|
||||
out = dict(eur_day=ed, cash=cash, snap=snap, hit=hit,
|
||||
p_target=float((ed >= pl.TARGET_EUR_DAY).mean()),
|
||||
p_ge10=float((ed >= 10.0).mean()),
|
||||
p_zero=float((cum_payout <= 0).mean()),
|
||||
med=float(np.median(ed)),
|
||||
med_cash=float(np.median(cash)), mean_cash=float(cash.mean()),
|
||||
p10_cash=float(np.percentile(cash, 10)),
|
||||
p90_cash=float(np.percentile(cash, 90)),
|
||||
med_spent=float(np.median(spent)), mean_back=float(got_back.mean()),
|
||||
n_tickets=float(n_tickets.mean()), n_pass=float(n_pass.mean()),
|
||||
peak_notional=float(np.median(peak_notional)),
|
||||
contributed=float(start_usd + deposited.mean()))
|
||||
bump(1)
|
||||
return out
|
||||
|
||||
|
||||
def p_wall_entro(res: dict, wall: float, giorni: int) -> float:
|
||||
"""P(il patrimonio PROPRIO tocca `wall` entro `giorni`) — obiettivo A."""
|
||||
h = res["hit"][wall]
|
||||
return float(((h >= 0) & (h < giorni)).mean())
|
||||
|
||||
|
||||
def anni_med(res: dict, wall: float) -> tuple[float, float]:
|
||||
"""(mediana INCONDIZIONATA degli anni al traguardo, P(arrivo entro la simulazione)).
|
||||
Non-arrivo = +inf, MAI -1 (lezione 07/08)."""
|
||||
h = res["hit"][wall]
|
||||
y = np.where(h >= 0, h / 365.0, np.inf)
|
||||
return float(np.median(y)), float(np.isfinite(y).mean())
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
def main() -> None:
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
|
||||
print("=" * 104)
|
||||
print(" §58 OBIETTIVO-DIRETTO — ottimizzare `P(reddito >= 50 EUR/g entro H)`, e non altro")
|
||||
print("=" * 104)
|
||||
print(f" {'MODALITA RIDOTTA (--fast)' if FAST else 'griglia piena'} | "
|
||||
f"{N_PATHS} percorsi | orizzonti {ORIZZONTI_M} mesi")
|
||||
|
||||
# ------------------------------------------------------------ §0 isolamento
|
||||
hr("§0. ISOLAMENTO — questo script NON tocca la produzione (il cron gira dal working tree)")
|
||||
prot = ["src", "config", "scripts/live", "tests", "data/paper_portfolio", "data/live"]
|
||||
dirty = subprocess.run(["git", "status", "--porcelain", "--"] + prot,
|
||||
cwd=ROOT, capture_output=True, text=True).stdout.strip()
|
||||
print(f" git status sui percorsi protetti {prot}:")
|
||||
print(f" {'PULITO — nessuna modifica' if not dirty else 'SPORCO: ' + dirty}")
|
||||
if dirty:
|
||||
raise SystemExit("La produzione risulta modificata: mi fermo.")
|
||||
print(" Nessuna scrittura su disco in tutto lo script (solo stdout). Rete: nessuna.")
|
||||
|
||||
# ------------------------------------------------------------ §1 repliche
|
||||
hr("§1. REPLICHE — prima di un numero nuovo, la macchina deve riprodurre i vecchi")
|
||||
ok: dict[str, bool] = {}
|
||||
|
||||
# (R1) il muro L3 (fisco + funding), $313.143 — §36, replicato al dollaro da §57
|
||||
print("\n R1 IL MURO della lente congiunta L3 (funding dentro, fisco dentro, de-luck x0,89)")
|
||||
rateF = GC.funding_rate()
|
||||
if rateF is None:
|
||||
raise SystemExit("cache funding assente: senza di essa nessun numero di questo filone "
|
||||
"sarebbe confrontabile coi pubblicati.")
|
||||
bookA = FD.book_75_25(None)
|
||||
bookF = FD.book_75_25(rateF).reindex(bookA.index)
|
||||
idxF = pd.DatetimeIndex(bookA.index)
|
||||
rL3 = np.asarray(bookF.values, float)
|
||||
rL3 = rL3 - (1.0 - DELUCK) * rL3.mean()
|
||||
prel = CC.TARGET_EUR_DAY * 365 * CC.EURUSD
|
||||
t = time.time()
|
||||
perp, MURO = PN.muro(rL3, prel, TAX, PATR)
|
||||
ok["R1"] = abs(MURO - PUB["muro_L3"]) < 1.0
|
||||
print(f" serie {len(rL3)} giorni {idxF.min().date()} -> {idxF.max().date()} | "
|
||||
f"drift {rL3.mean()*365:.4%} (pubbl. {PUB['drift_L3']:.2%})")
|
||||
print(f" perpetua {perp:.4%} (pubbl. {PUB['perp_L3']:.2%}) muro ${MURO:,.0f} "
|
||||
f"(pubbl. ${PUB['muro_L3']:,.0f}) -> "
|
||||
f"{'ESATTO AL DOLLARO' if ok['R1'] else 'DIVERSO'} ({time.time()-t:.0f}s)")
|
||||
bump(1)
|
||||
tick("R1")
|
||||
|
||||
# ------------------------------------------------- il pannello comune
|
||||
print("\n Il pannello comune (identico a §29/§32/§37): U13 Binance, W-LONG 2021+.")
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
XSP = {ph: PR.xs_tuples(p13, Ob.reindex(p13.index)[X.U13], Hb.reindex(p13.index)[X.U13],
|
||||
Lb.reindex(p13.index)[X.U13], phase=ph) for ph in PHASES_SUB}
|
||||
xs0 = XSP[PHASES_SUB[0]]
|
||||
base = pc.crypto_daily_tuples(1.0, 0.0).index.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
I = base[base >= max(first13, pd.Timestamp("2021-01-01", tz="UTC"))]
|
||||
pc.DELUCK = DELUCK
|
||||
ev_b = PA.boot_idx(len(I), 365, N_PATHS_J, seed=8220)
|
||||
fu_b = PA.boot_idx(len(I), 365, N_PATHS_J, seed=8221)
|
||||
xsf = GC.xs_funding_measure(verbose=False)
|
||||
xs_ann = xsf["ann"]
|
||||
print(f" {len(I)} giorni {I[0].date()} -> {I[-1].date()} | "
|
||||
f"XS01 paga {xs_ann*100:+.2f}%/anno di funding (misurato §37)")
|
||||
tick("pannello")
|
||||
|
||||
# (R2) la cella d'ancora MEDIANA e il numero operativo 2,6% [1,5%, 4,7%]
|
||||
print(f"\n R2 IL NUMERO OPERATIVO DI §37 — {len(OFFSETS_SUB)} offset x {len(PHASES_SUB)} "
|
||||
f"fasi = {len(OFFSETS_SUB)*len(PHASES_SUB)} celle, funding DENTRO, leva argmax-J")
|
||||
print(" (sottoinsieme d'ancore dichiarato PRIMA; §37 ne usa 23x3, qui se ne usano "
|
||||
f"{len(OFFSETS_SUB)}x{len(PHASES_SUB)} per il tempo macchina)")
|
||||
cells = []
|
||||
for off in OFFSETS_SUB:
|
||||
fA = GC.fvec_for(W_A, I, rateF, off, xs_ann)
|
||||
for ph in PHASES_SUB:
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rx = R0 - fA
|
||||
jb, lb = -1.0, None
|
||||
for lv in PR.LEVS:
|
||||
j = PR.obj_rg(Rx, G0, lv, ev_b, fu_b)["J"]
|
||||
if j > jb:
|
||||
jb, lb = j, lv
|
||||
bump(len(PR.LEVS))
|
||||
lad = GC.ladder(Rx, G0, N_PATHS, lb, SEED_LAD, refund=False)
|
||||
cells.append(dict(off=off, ph=ph, J=jb, lev=lb, p50=lad["p_target"],
|
||||
pz=lad["p_zero"], med=lad["med"]))
|
||||
bump(1)
|
||||
C = pd.DataFrame(cells)
|
||||
med_p, p10, p90 = C["p50"].median(), np.percentile(C["p50"], 10), np.percentile(C["p50"], 90)
|
||||
ok["R2"] = PUB["p50g_p10"] <= med_p <= PUB["p50g_p90"]
|
||||
print(f" P(>=50/g) mediana {med_p:.1%} banda [{p10:.1%}, {p90:.1%}] "
|
||||
f"P(zero) {C['pz'].median():.1%}")
|
||||
print(f" pubblicato §37: {PUB['p50g_fund']:.1%} [{PUB['p50g_p10']:.1%}, "
|
||||
f"{PUB['p50g_p90']:.1%}], P(zero) {PUB['pzero_fund']:.1%} -> "
|
||||
f"{'DENTRO LA BANDA' if ok['R2'] else 'FUORI'}")
|
||||
k_med = int((C["p50"] - C["p50"].median()).abs().idxmin())
|
||||
OFF_M, PH_M, LEV_J = int(C.loc[k_med, "off"]), int(C.loc[k_med, "ph"]), float(C.loc[k_med, "lev"])
|
||||
print(f" CELLA D'ANCORA MEDIANA: offset {OFF_M} min, fase {PH_M}, leva argmax-J "
|
||||
f"{LEV_J:.2f}x (non la canonica: 91° pctl, §32)")
|
||||
fM = GC.fvec_for(W_A, I, rateF, OFF_M, xs_ann)
|
||||
R_M0, G_M = AP.rg_off(W_A, I, XSP[PH_M], OFF_M)
|
||||
R_M = R_M0 - fM
|
||||
tick("R2")
|
||||
|
||||
# il libro PROPRIO sullo stesso pannello
|
||||
rb_full = FD.book_75_25(rateF)
|
||||
if rb_full.index.tz is None:
|
||||
rb_full.index = rb_full.index.tz_localize("UTC")
|
||||
RB_LIVE = np.nan_to_num(rb_full.reindex(I).values.astype(float))
|
||||
fA_own = GC.fvec_for(W_A, I, rateF, OFF_M, xs_ann)
|
||||
RB_WA = AP.rg_off(W_A, I, XSP[PH_M], OFF_M)[0] - fA_own
|
||||
print(f"\n libro PROPRIO sul pannello comune:")
|
||||
for lab, r in (("LIVE 75/25", RB_LIVE), ("W_A 38/38/25", RB_WA)):
|
||||
print(f" {lab:<14} drift {r.mean()*365:>7.2%} vol {r.std()*365**.5:>6.2%} "
|
||||
f"Sharpe {r.mean()*365/(r.std()*365**.5):>5.2f}")
|
||||
|
||||
# bootstrap CONDIVISO (confronto appaiato fra tutte le politiche)
|
||||
rngb = np.random.default_rng(SEED_BOOT)
|
||||
nb = int(np.ceil(H_MAX_D / 20))
|
||||
st = rngb.integers(0, len(I) - 20, size=(N_PATHS, nb))
|
||||
BOOT = (st[:, :, None] + np.arange(20)[None, None, :]).reshape(N_PATHS, -1)[:, :H_MAX_D]
|
||||
B36 = BOOT[:, :36 * 30]
|
||||
print(f" bootstrap CONDIVISO: {N_PATHS} percorsi x {H_MAX_D} giorni, blocchi 20 -> "
|
||||
f"OGNI confronto di questo filone e' APPAIATO")
|
||||
|
||||
# (R3) bit-exactness: `uni` in modalita' ladder == `gate_c.ladder`
|
||||
print("\n R3 BIT-EXACTNESS — `uni` in modalita' ladder deve essere `gate_c.ladder`")
|
||||
ref = GC.ladder(R_M, G_M, N_PATHS, LEV_J, SEED_LAD, refund=False, boot=B36)
|
||||
mine = uni(R_M, G_M, RB_LIVE, B36, lev_fu=LEV_J, n_max=pl.MAX_CONCURRENT, pref="grande",
|
||||
rebuy=True, floor_usd=0.0, k_book=0.0, invest=False, dep_eur=0.0,
|
||||
start_usd=pl.START_EUR * EURUSD, seed=SEED_LAD, refund=False, min_payout=0.0,
|
||||
tax=0.0, patr=0.0, deposit_mode="ladder")
|
||||
d1 = float(np.abs(ref["eur_day"] - mine["eur_day"]).max())
|
||||
d2 = float(np.abs(ref["cash"] - mine["cash"]).max())
|
||||
ok["R3"] = (d1 == 0.0 and d2 == 0.0)
|
||||
print(f" max|dif| EUR/g = {d1:.3e} | max|dif| cassa = {d2:.3e} -> "
|
||||
f"{'BIT-EXACT' if ok['R3'] else 'DIVERSO'}")
|
||||
|
||||
# (R4) bit-exactness: `uni` senza conti == `PN.accumula`
|
||||
print("\n R4 BIT-EXACTNESS — `uni` senza canale funded deve essere `PN.accumula`")
|
||||
paths_own = (RB_LIVE - (1.0 - DELUCK) * RB_LIVE.mean())[B36]
|
||||
a = PN.accumula(paths_own, 500.0, MURO, TAX, PATR, start=START_USD)
|
||||
m = uni(R_M, G_M, RB_LIVE, B36, n_max=0, k_book=1.0, invest=True, dep_eur=500.0,
|
||||
start_usd=START_USD, tax=TAX, patr=PATR, walls=(MURO,),
|
||||
deposit_mode="accumula")
|
||||
d3 = float(np.abs(a["cap"] - m["cash"]).max())
|
||||
d4 = int(np.abs(np.where(a["colpito"] >= 0, a["colpito"], -1) - m["hit"][MURO]).max())
|
||||
ok["R4"] = (d3 < 1e-6 and d4 == 0)
|
||||
print(f" max|dif| capitale = ${d3:.3e} | max|dif| giorno di primo passaggio = {d4} -> "
|
||||
f"{'BIT-EXACT' if ok['R4'] else 'DIVERSO'}")
|
||||
print(f" (capitale mediano a 36 mesi ${np.median(m['cash']):,.0f}, "
|
||||
f"P(muro) {float((m['hit'][MURO]>=0).mean()):.1%})")
|
||||
|
||||
print(f"\n ESITO REPLICHE: {sum(ok.values())}/{len(ok)} — "
|
||||
+ ", ".join(f"{k}={'OK' if v else 'NO'}" for k, v in ok.items()))
|
||||
if not all(ok.values()):
|
||||
raise SystemExit("REPLICA INCOMPLETA: un numero nuovo sarebbe indistinguibile da un bug.")
|
||||
tick("§1")
|
||||
# ---- fine repliche; da qui i numeri NUOVI
|
||||
|
||||
# muro coerente col PANNELLO su cui gira la simulazione (2021+), come sensibilita'
|
||||
rI = RB_LIVE - (1.0 - DELUCK) * RB_LIVE.mean()
|
||||
lo, hi = 0.0, 0.40
|
||||
for _ in range(13):
|
||||
mid = (lo + hi) / 2
|
||||
sv = PN.sopravvivenza(rI, 1e6, 1e6 * mid, 20, TAX, PATR, n_paths=1500)
|
||||
lo, hi = (mid, hi) if sv["p10_end"] >= 1e6 else (lo, mid)
|
||||
MURO_I = prel / lo if lo > 0.002 else float("inf")
|
||||
WALLS = (PUB["muro_p90"], MURO, PUB["muro_m1se"])
|
||||
print(f"\n IL BERSAGLIO (obiettivo A) — e la sua banda, propagata da §57:")
|
||||
print(f" muro PRIMARIO (pubblicato, finestra piena 2019+): ${MURO:,.0f} "
|
||||
f"(perpetua {perp:.2%})")
|
||||
print(f" banda del drift +-1SE (§57): p90 ${PUB['muro_p90']:,.0f} ... "
|
||||
f"-1SE ${PUB['muro_m1se']:,.0f}")
|
||||
print(f" muro COERENTE col pannello 2021+ (drift {rI.mean()*365:.2%}): "
|
||||
+ (f"${MURO_I:,.0f}" if np.isfinite(MURO_I) else "IRRAGGIUNGIBILE (perpetua ~0)"))
|
||||
print(" ⚠️ La simulazione gira sul pannello 2021+ (l'unico dove XS01 esiste) mentre il muro")
|
||||
print(" pubblicato e' calcolato sulla finestra piena: la disparita' e' DICHIARATA e la")
|
||||
print(" riga qui sopra la quantifica. Primaria resta la pubblicata, per confrontabilita'.")
|
||||
tick("muro")
|
||||
|
||||
def run(**kw) -> dict:
|
||||
base = dict(lev_fu=1.0, n_max=0, pref="grande", rebuy=True, floor_usd=0.0,
|
||||
k_book=1.0, invest=True, dep_eur=500.0, start_usd=START_USD,
|
||||
seed=SEED_LAD, refund=True, min_payout=MIN_PAYOUT, tax=TAX, patr=PATR,
|
||||
walls=WALLS, marks=MARKS, deposit_mode="ladder")
|
||||
base.update(kw)
|
||||
boot = base.pop("boot", BOOT)
|
||||
return uni(base.pop("Ra", R_M), base.pop("Ga", G_M), base.pop("Rb", RB_LIVE),
|
||||
boot, **base)
|
||||
|
||||
# ======================================================================
|
||||
hr("§2. LE DUE DEFINIZIONI DI «REDDITO >= 50 EUR/g», SULLA STESSA POLITICA E SUGLI STESSI PATH")
|
||||
print(" A = RICCHEZZA: il patrimonio PROPRIO tocca il capitale-rendita (sostenibile).")
|
||||
print(" B = FLUSSO : media dei payout incassati >= 50 EUR/g (la definizione dei numeri")
|
||||
print(" pubblicati del canale funded — NON sostenibile).")
|
||||
print(f" Versamento: EUR 500/mese (il piano in `config/live.json`), start ${START_USD:,.0f}.")
|
||||
REF = {
|
||||
"LIBRO (oggi: 75/25, k=1, nessun biglietto)": dict(n_max=0),
|
||||
"PROP come pubblicato (6 conti, leva argmax-J, cassa FERMA)":
|
||||
dict(n_max=6, lev_fu=LEV_J, invest=False, k_book=0.0, tax=0.0, patr=0.0),
|
||||
"PROP + cassa che lavora sul libro (stessa leva)":
|
||||
dict(n_max=6, lev_fu=LEV_J, invest=True, k_book=1.0),
|
||||
}
|
||||
refres = {k: run(**v) for k, v in REF.items()}
|
||||
print(f"\n {'politica':<52} {'H':>5} {'A: P(muro)':>11} {'B: P(>=50/g)':>13} "
|
||||
f"{'mediana $':>11} {'P(<versato)':>12}")
|
||||
for lab, r in refres.items():
|
||||
for m in ORIZZONTI_M:
|
||||
sn = r["snap"][m * 30]
|
||||
print(f" {lab if m == ORIZZONTI_M[0] else '':<52} {m:>4}m "
|
||||
f"{sn[f'A{MURO:.0f}']:>11.1%} {sn['p_flow']:>13.1%} "
|
||||
f"${sn['med_cash']:>10,.0f} {sn['p_sotto']:>12.1%}")
|
||||
print("\n 📌 Le due definizioni NON ordinano le politiche allo stesso modo, e a 36 mesi non")
|
||||
print(" sono nemmeno commensurabili: sotto A il canale funded e' un ACCELERATORE di")
|
||||
print(" capitale, sotto B e' l'unico modo di avere un flusso.")
|
||||
tick("§2")
|
||||
|
||||
# ======================================================================
|
||||
hr("§3. LA CURVA DI LEVA — dove sta l'argmax di CIASCUN obiettivo (attesa A1)")
|
||||
print(f" Cella d'ancora mediana (offset {OFF_M}, fase {PH_M}), 6 conti, cassa che lavora,")
|
||||
print(" EUR 500/mese. J e' calcolato con la STESSA `PR.obj_rg` di §29/§32/§37.")
|
||||
print(f"\n {'leva':>6} {'J':>7} {'B: P(>=50/g) 36m':>17} {'A: P(muro) 120m':>16} "
|
||||
f"{'P(zero)':>8} {'P(<versato)':>12} {'mediana $ 120m':>15}")
|
||||
LEVS_ALL = PR.LEVS
|
||||
curve = []
|
||||
for lv in LEVS_ALL:
|
||||
j = PR.obj_rg(R_M, G_M, lv, ev_b, fu_b)["J"]
|
||||
bump(1)
|
||||
r = run(n_max=6, lev_fu=lv)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
curve.append(dict(lev=lv, J=j, B36=s36["p_flow"], A120=s120[f"A{MURO:.0f}"],
|
||||
pz=s36["p_zero"], psotto=s120["p_sotto"], med=s120["med_cash"]))
|
||||
print(f" {lv:>6.3f} {j:>7.3f} {s36['p_flow']:>17.1%} {s120[f'A{MURO:.0f}']:>16.1%} "
|
||||
f"{s36['p_zero']:>8.1%} {s120['p_sotto']:>12.1%} ${s120['med_cash']:>14,.0f}")
|
||||
CU = pd.DataFrame(curve)
|
||||
aJ = float(CU.loc[CU["J"].idxmax(), "lev"])
|
||||
aB = float(CU.loc[CU["B36"].idxmax(), "lev"])
|
||||
aA = float(CU.loc[CU["A120"].idxmax(), "lev"])
|
||||
print(f"\n argmax J = {aJ:.2f}x · argmax B(36m) = {aB:.2f}x · "
|
||||
f"argmax A(120m) = {aA:.2f}x")
|
||||
print(f" B alla leva argmax-J: {float(CU.loc[CU['J'].idxmax(),'B36']):.1%} -> "
|
||||
f"B al proprio argmax: {CU['B36'].max():.1%} "
|
||||
f"(fattore {CU['B36'].max()/max(float(CU.loc[CU['J'].idxmax(),'B36']),1e-9):.1f}x)")
|
||||
print(f" ATTESA A1 ({'CONFERMATA' if aB > aJ and CU['B36'].max() > 2*float(CU.loc[CU['J'].idxmax(),'B36']) else 'PARZIALE/SMENTITA'}): "
|
||||
"l'argmax di P sta a leva piu' alta di quello di J.")
|
||||
tick("§3")
|
||||
|
||||
# ======================================================================
|
||||
hr("§4. LO SPAZIO DI POLITICA, OTTIMIZZATO SU P DIRETTAMENTE (36 mesi, obiettivo B)")
|
||||
grid = [dict(lev_fu=lv, n_max=nm, pref=pf, rebuy=rb)
|
||||
for lv in LEVS_FU for nm in NMAX for pf in PREFS for rb in REBUY]
|
||||
print(f" {len(grid)} celle dichiarate PRIMA: leva {LEVS_FU} x conti {NMAX} x "
|
||||
f"taglia {PREFS} x rebuy {REBUY}")
|
||||
print(f" fisse: libro proprio LIVE 75/25 k=1, cassa che lavora, floor $0, EUR 500/mese.")
|
||||
rows = []
|
||||
for g in grid:
|
||||
r = run(**g)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
rows.append(dict(**g, B36=s36["p_flow"], B24=r["snap"][24 * 30]["p_flow"],
|
||||
B60=r["snap"][60 * 30]["p_flow"], B120=s120["p_flow"],
|
||||
A36=s36[f"A{MURO:.0f}"], A120=s120[f"A{MURO:.0f}"],
|
||||
A120lo=s120[f"A{PUB['muro_p90']:.0f}"],
|
||||
A120hi=s120[f"A{PUB['muro_m1se']:.0f}"],
|
||||
pz=s36["p_zero"], psotto36=s36["p_sotto"],
|
||||
rov36=s36["p_rovina"], med120=s120["med_cash"],
|
||||
ntick=r["n_tickets"]))
|
||||
G = pd.DataFrame(rows)
|
||||
print(f"\n LE 8 MIGLIORI SU B(36 mesi) — e cosa costano sugli altri assi:")
|
||||
print(f" {'leva':>5} {'conti':>6} {'taglia':>8} {'rebuy':>6} {'B 24m':>7} {'B 36m':>7} "
|
||||
f"{'B 60m':>7} {'A 120m':>7} {'P(zero)':>8} {'P(<vers) 36m':>13} {'bigl.':>6}")
|
||||
for _, r in G.sort_values("B36", ascending=False).head(8).iterrows():
|
||||
print(f" {r['lev_fu']:>5.2f} {int(r['n_max']):>6} {r['pref']:>8} "
|
||||
f"{'si' if r['rebuy'] else 'no':>6} {r['B24']:>7.1%} {r['B36']:>7.1%} "
|
||||
f"{r['B60']:>7.1%} {r['A120']:>7.1%} {r['pz']:>8.1%} {r['psotto36']:>13.1%} "
|
||||
f"{r['ntick']:>6.1f}")
|
||||
print(f"\n LE 6 MIGLIORI SU A(120 mesi, muro pubblicato ${MURO:,.0f}):")
|
||||
print(f" {'leva':>5} {'conti':>6} {'taglia':>8} {'rebuy':>6} {'A 36m':>7} {'A 120m':>7} "
|
||||
f"{'A120 p90':>9} {'A120 -1SE':>10} {'B 36m':>7} {'mediana $ 120m':>15}")
|
||||
for _, r in G.sort_values("A120", ascending=False).head(6).iterrows():
|
||||
print(f" {r['lev_fu']:>5.2f} {int(r['n_max']):>6} {r['pref']:>8} "
|
||||
f"{'si' if r['rebuy'] else 'no':>6} {r['A36']:>7.1%} {r['A120']:>7.1%} "
|
||||
f"{r['A120lo']:>9.1%} {r['A120hi']:>10.1%} {r['B36']:>7.1%} "
|
||||
f"${r['med120']:>14,.0f}")
|
||||
bestB = G.loc[G["B36"].idxmax()]
|
||||
bestA = G.loc[G["A120"].idxmax()]
|
||||
print(f"\n ARGMAX B(36m) = leva {bestB['lev_fu']:.2f}x, {int(bestB['n_max'])} conti, "
|
||||
f"biglietto {bestB['pref']}, rebuy {'si' if bestB['rebuy'] else 'no'} -> "
|
||||
f"{bestB['B36']:.1%}")
|
||||
print(f" ARGMAX A(120m) = leva {bestA['lev_fu']:.2f}x, {int(bestA['n_max'])} conti, "
|
||||
f"biglietto {bestA['pref']}, rebuy {'si' if bestA['rebuy'] else 'no'} -> "
|
||||
f"{bestA['A120']:.1%}")
|
||||
print(f" I due argmax {'COINCIDONO' if (bestB[['lev_fu','n_max','pref','rebuy']].tolist() == bestA[['lev_fu','n_max','pref','rebuy']].tolist()) else 'SONO DIVERSI'}.")
|
||||
tick("§4")
|
||||
|
||||
# ======================================================================
|
||||
hr("§5. LE DIMENSIONI RESTANTI — floor, versamento, leva del libro, ripartizione propria")
|
||||
bp = dict(lev_fu=float(bestB["lev_fu"]), n_max=int(bestB["n_max"]),
|
||||
pref=str(bestB["pref"]), rebuy=bool(bestB["rebuy"]))
|
||||
print(f" Politica di riferimento: l'argmax di B {bp}")
|
||||
print(f"\n (a) FLOOR — capitale proprio sotto cui non si compra un altro biglietto")
|
||||
print(f" {'floor':>10} {'B 36m':>8} {'A 120m':>8} {'P(zero)':>9} {'mediana $ 120m':>15}")
|
||||
for fl in (0.0, 2_000.0, 10_000.0):
|
||||
r = run(floor_usd=fl, **bp)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
print(f" ${fl:>9,.0f} {s36['p_flow']:>8.1%} {s120[f'A{MURO:.0f}']:>8.1%} "
|
||||
f"{s36['p_zero']:>9.1%} ${s120['med_cash']:>14,.0f}")
|
||||
print(f"\n (b) VERSAMENTO MENSILE — la leva che il progetto misura come dominante")
|
||||
print(f" {'EUR/mese':>10} {'strada':>10} {'B 36m':>8} {'A 120m':>8} {'A 240m':>8} "
|
||||
f"{'mediana $ 120m':>15}")
|
||||
for dep in (0.0, 250.0, 500.0, 1_000.0):
|
||||
for lab, kw in (("PROP", bp), ("LIBRO", dict(n_max=0))):
|
||||
r = run(dep_eur=dep, **kw)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
a240 = anni_med(r, MURO)
|
||||
print(f" {dep:>10,.0f} {lab:>10} {s36['p_flow']:>8.1%} "
|
||||
f"{s120[f'A{MURO:.0f}']:>8.1%} {a240[1]:>8.1%} ${s120['med_cash']:>14,.0f}")
|
||||
print(" (la colonna 'A 240m' e' P(traguardo) sull'intera simulazione = 120 mesi: coincide")
|
||||
print(" con A 120m — la si stampa per rendere esplicito che l'orizzonte massimo e' 10 anni)")
|
||||
print(f"\n (c) LEVA DEL LIBRO PROPRIO — muro CONGELATO (primaria) e MOBILE (sensibilita')")
|
||||
print(" ⚠️ §38: la chiave di scala NON ESISTE in `config/live.json`; §57: a k=1,50x il")
|
||||
print(" peggior giorno e' 21,48% e la guardia dello scettico (<=20%) lo BOCCIA.")
|
||||
print(f" {'k':>5} {'muro mobile':>13} {'A 120m congel.':>15} {'A 120m mobile':>14} "
|
||||
f"{'B 36m':>7} {'mediana $ 120m':>15}")
|
||||
for k in (1.00, 1.25, 1.50):
|
||||
rk = rI * k
|
||||
lo, hi = 0.0, 0.40
|
||||
for _ in range(11):
|
||||
mid = (lo + hi) / 2
|
||||
sv = PN.sopravvivenza(np.asarray(rL3, float) * k, 1e6, 1e6 * mid, 20, TAX, PATR,
|
||||
n_paths=1200)
|
||||
lo, hi = (mid, hi) if sv["p10_end"] >= 1e6 else (lo, mid)
|
||||
mk = prel / lo if lo > 0.002 else float("inf")
|
||||
r = run(k_book=k, walls=(MURO, mk) if np.isfinite(mk) else (MURO,), **bp)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
am = s120.get(f"A{mk:.0f}", float("nan")) if np.isfinite(mk) else float("nan")
|
||||
print(f" {k:>5.2f} " + (f"${mk:>12,.0f}" if np.isfinite(mk) else f"{'IRRAGG.':>13}")
|
||||
+ f" {s120[f'A{MURO:.0f}']:>15.1%} "
|
||||
+ (f"{am:>14.1%}" if am == am else f"{'—':>14}")
|
||||
+ f" {s36['p_flow']:>7.1%} ${s120['med_cash']:>14,.0f}")
|
||||
bump(1)
|
||||
print(f"\n (d) RIPARTIZIONE DEL LIBRO PROPRIO — LIVE 75/25 contro W_A 38/38/25")
|
||||
print(" (la seconda mette XS01 anche sul capitale proprio: §46 ha falsificato la soglia")
|
||||
print(" dei $20k da min-order, ma la decisione di venue del 26/07 tiene tutto su")
|
||||
print(" Deribit fino a $20k -> e' una sensibilita', non una proposta)")
|
||||
print(f" {'libro proprio':>16} {'B 36m':>8} {'A 120m':>8} {'mediana $ 120m':>15}")
|
||||
for lab, rbk in (("LIVE 75/25", RB_LIVE), ("W_A 38/38/25", RB_WA)):
|
||||
r = run(Rb=rbk, **bp)
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
print(f" {lab:>16} {s36['p_flow']:>8.1%} {s120[f'A{MURO:.0f}']:>8.1%} "
|
||||
f"${s120['med_cash']:>14,.0f}")
|
||||
print(f"\n (e) LA CASSA CHE LAVORA — attesa A3")
|
||||
print(f" {'cassa':>16} {'B 36m':>8} {'A 120m':>8} {'mediana $ 36m':>14} "
|
||||
f"{'mediana $ 120m':>15}")
|
||||
inv = {}
|
||||
for lab, kw in (("ferma (pubbl.)", dict(invest=False, k_book=0.0, tax=0.0, patr=0.0)),
|
||||
("investita", dict(invest=True, k_book=1.0))):
|
||||
r = run(**{**bp, **kw})
|
||||
inv[lab] = r
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
print(f" {lab:>16} {s36['p_flow']:>8.1%} {s120[f'A{MURO:.0f}']:>8.1%} "
|
||||
f"${s36['med_cash']:>13,.0f} ${s120['med_cash']:>14,.0f}")
|
||||
dB = (inv["investita"]["snap"][36 * 30]["p_flow"]
|
||||
- inv["ferma (pubbl.)"]["snap"][36 * 30]["p_flow"])
|
||||
dA = (inv["investita"]["snap"][120 * 30][f"A{MURO:.0f}"]
|
||||
- inv["ferma (pubbl.)"]["snap"][120 * 30][f"A{MURO:.0f}"])
|
||||
print(f" ATTESA A3: dB {dB*100:+.2f}pp, dA {dA*100:+.2f}pp -> "
|
||||
f"{'CONFERMATA' if abs(dB) < 0.02 and dA > 0.02 else 'da leggere nel testo'}")
|
||||
tick("§5")
|
||||
|
||||
# ======================================================================
|
||||
hr("§6. QUANTO COSTA LA DIFFERENZA FRA L'OTTIMO E CIO' CHE IL PROGETTO FA OGGI")
|
||||
oggi = run(n_max=0)
|
||||
pubb = run(n_max=6, lev_fu=LEV_J, invest=False, k_book=0.0, tax=0.0, patr=0.0)
|
||||
optB = run(**bp)
|
||||
optA = run(lev_fu=float(bestA["lev_fu"]), n_max=int(bestA["n_max"]),
|
||||
pref=str(bestA["pref"]), rebuy=bool(bestA["rebuy"]))
|
||||
print(f" {'politica':<44} {'B 36m':>8} {'A 36m':>8} {'A 120m':>8} {'anni al muro':>13} "
|
||||
f"{'P(<versato) 36m':>16}")
|
||||
for lab, r in (("OGGI: libro 75/25 k=1, nessun biglietto", oggi),
|
||||
("PUBBLICATA: 6 conti a leva argmax-J", pubb),
|
||||
("ARGMAX B (flusso)", optB),
|
||||
("ARGMAX A (ricchezza)", optA)):
|
||||
s36, s120 = r["snap"][36 * 30], r["snap"][120 * 30]
|
||||
med, parr = anni_med(r, MURO)
|
||||
print(f" {lab:<44} {s36['p_flow']:>8.1%} {s36[f'A{MURO:.0f}']:>8.1%} "
|
||||
f"{s120[f'A{MURO:.0f}']:>8.1%} "
|
||||
+ (f"{med:>12.1f}a" if np.isfinite(med) else f"{'>10a':>13}")
|
||||
+ f" {s36['p_sotto']:>16.1%}")
|
||||
dB36 = optB["snap"][36 * 30]["p_flow"] - oggi["snap"][36 * 30]["p_flow"]
|
||||
dA120 = optA["snap"][120 * 30][f"A{MURO:.0f}"] - oggi["snap"][120 * 30][f"A{MURO:.0f}"]
|
||||
print(f"\n COSTO DI NON OTTIMIZZARE: su B(36m) {dB36*100:+.1f}pp, "
|
||||
f"su A(120m) {dA120*100:+.1f}pp.")
|
||||
tick("§6")
|
||||
|
||||
# ======================================================================
|
||||
hr("§7. LA DOMANDA DECISIVA — esiste una politica con P(>=50 EUR/g entro 36 mesi) > 20%?")
|
||||
maxB = float(G["B36"].max())
|
||||
maxA36 = float(G["A36"].max())
|
||||
rowB = G.loc[G["B36"].idxmax()]
|
||||
print(f" Sotto la definizione B (FLUSSO, quella dei numeri pubblicati):")
|
||||
print(f" massimo su {len(G)} politiche = {maxB:.1%} "
|
||||
f"(leva {rowB['lev_fu']:.2f}x, {int(rowB['n_max'])} conti, biglietto {rowB['pref']}, "
|
||||
f"rebuy {'si' if rowB['rebuy'] else 'no'})")
|
||||
print(f" ma con P(zero payout) {rowB['pz']:.1%} e P(finire sotto il versato) "
|
||||
f"{rowB['psotto36']:.1%}")
|
||||
print(f" -> {'SI, SOPRA IL 20%' if maxB > 0.20 else 'NO, SOTTO IL 20%'}")
|
||||
print(f"\n Sotto la definizione A (RICCHEZZA sostenibile, il muro del progetto):")
|
||||
print(f" massimo su {len(G)} politiche a 36 mesi = {maxA36:.2%} "
|
||||
f"(a 120 mesi: {float(G['A120'].max()):.1%})")
|
||||
print(f" -> {'SI' if maxA36 > 0.20 else 'NO'}, e non per poco: il muro e' "
|
||||
f"${MURO:,.0f} e a 36 mesi il capitale mediano migliore e' "
|
||||
f"${float(G['med120'].max()):,.0f} a 120 mesi.")
|
||||
print(f"\n ATTESA A2 ({'CONFERMATA' if (maxB > 0.20 and maxA36 < 0.05) else 'SMENTITA'}): "
|
||||
"«SI' sotto B e NO sotto A».")
|
||||
print(f" ATTESA A4 ({'CONFERMATA' if rowB['pz'] > 0.50 or rowB['psotto36'] > 0.50 else 'SMENTITA'}): "
|
||||
"l'ottimo di P e' una politica ad alta rovina.")
|
||||
|
||||
# il vincolo che fissa il massimo
|
||||
print(f"\n QUALE VINCOLO FISSA IL MASSIMO — si toglie un vincolo per volta (obiettivo B, 36m):")
|
||||
print(f" {'scenario':<46} {'B 36m':>8} {'delta':>8}")
|
||||
base_b = float(rowB["B36"])
|
||||
scen = []
|
||||
r = run(start_usd=10_000.0, **bp); scen.append(("capitale iniziale $10.000 invece di $635", r))
|
||||
r = run(dep_eur=2_000.0, **bp); scen.append(("versamento EUR 2.000/mese invece di 500", r))
|
||||
cap_old = [F["cap"] for F in pl.FIRMS]
|
||||
for F in pl.FIRMS:
|
||||
F["cap"] *= 5
|
||||
r = run(**bp); scen.append(("cap per firm x5 ($1M / $2M)", r))
|
||||
for F, c in zip(pl.FIRMS, cap_old):
|
||||
F["cap"] = c
|
||||
dead_old = pl.FIRM_DEATH_PER_YEAR
|
||||
pl.FIRM_DEATH_PER_YEAR = 0.0
|
||||
r = run(**bp); scen.append(("morte-firm 0%/anno invece di 10%", r))
|
||||
pl.FIRM_DEATH_PER_YEAR = dead_old
|
||||
r = run(n_max=6, **{k: v for k, v in bp.items() if k != "n_max"})
|
||||
scen.append(("6 conti concorrenti (se non lo e' gia')", r))
|
||||
for lab, r in scen:
|
||||
b = r["snap"][36 * 30]["p_flow"]
|
||||
print(f" {lab:<46} {b:>8.1%} {(b-base_b)*100:>+7.1f}pp")
|
||||
print(f" ATTESA A5: il vincolo binding e' il capitale che entra "
|
||||
f"(riga 'versamento' e riga 'capitale iniziale').")
|
||||
|
||||
# ======================================================================
|
||||
hr("VERDETTO")
|
||||
eur_g_oggi = oggi["snap"][36 * 30]["med_cash"]
|
||||
print(f" Trial contati al rialzo: {TRIALS}. Tempo {time.time()-T0:.0f}s. "
|
||||
f"Percorsi {N_PATHS} (SE ~{100*np.sqrt(0.2*0.8/N_PATHS):.1f}pp su una P vicina al 20%).")
|
||||
print(f"\n * L'obiettivo del progetto ha DUE definizioni operative in uso e danno risposte")
|
||||
print(f" opposte alla stessa domanda. Con la definizione del canale funded (FLUSSO) il")
|
||||
print(f" massimo a 36 mesi e' {maxB:.1%}; con quella dei muri e del piano (RICCHEZZA")
|
||||
print(f" SOSTENIBILE) e' {maxA36:.2%}.")
|
||||
print(f" * L'ottimo di P(>=50/g) NON e' l'ottimo di J: {CU['B36'].max():.1%} contro "
|
||||
f"{float(CU.loc[CU['J'].idxmax(),'B36']):.1%} alla leva argmax-J.")
|
||||
print(f" * In EUR/giorno, la mediana di cio' che il libro di oggi produce a 36 mesi resta")
|
||||
print(f" ZERO (non preleva), e il capitale mediano e' ${eur_g_oggi:,.0f}: la rendita")
|
||||
print(f" perpetua su quel capitale vale {perp*eur_g_oggi/365/EURUSD:.2f} EUR/giorno.")
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,964 @@
|
||||
"""§68 QUASI-PASSATI — i candidati morti per pochissimo, presi INSIEME, passano?
|
||||
|
||||
DOMANDA
|
||||
=======
|
||||
In due mesi il progetto ha bocciato decine di candidati e molti sono morti *per un soffio*:
|
||||
deflated-Sharpe 0,948 (tenore VRP, bocciato per 0,002), 0,947 (cella pubblicata DVOLSPREAD),
|
||||
0,929 (STATARB same-sign), 0,905 (cella viva di PREVDAY), e `weights_tilt_null` fallito per
|
||||
delta_insample -0,004 (XSR01). Nessuno ha mai chiesto se, MESSI INSIEME, formino qualcosa che
|
||||
passa. La domanda e' legittima perche' sono meccanismi DIVERSI (opzioni, spread di vol, residuo
|
||||
cross-asset, livelli del giorno prima, cross-section su 50 alt) -> la loro combinazione non e'
|
||||
automaticamente ridondante.
|
||||
|
||||
Ma e' ANCHE la forma classica del data-dredging: raccogliere i falliti finche' la media non passa.
|
||||
IL COMPITO E' MISURARE QUALE DELLE DUE COSE E', NON TROVARE UN VINCITORE.
|
||||
|
||||
REGOLA DI AMMISSIONE — DICHIARATA PRIMA DI MISURARE, NON CAMBIATA DOPO
|
||||
=====================================================================
|
||||
Entra nel paniere ogni candidato che soddisfa TUTTE E TRE:
|
||||
(R1) NON e' nel libro LIVE ne' nel book di ricerca a 5 sleeve (= candidato respinto o in limbo);
|
||||
(R2) l'esito pubblicato dista <= 0,05 dalla soglia del gate che lo ha fermato:
|
||||
|DSR - 0,95| <= 0,05 OPPURE |delta_insample| <= 0,01 su `weights_tilt_null`;
|
||||
(R3) la serie e' RICOSTRUIBILE da codice committato coi parametri congelati/pubblicati.
|
||||
La rappresentante di ogni candidato e' la CELLA CONGELATA NEL MONITOR (o, se monitor non esiste,
|
||||
la cella pubblicata). PESI UGUALI. NESSUNA selezione successiva: il leave-one-out e' diagnostica,
|
||||
non una potatura. Nessun candidato viene aggiunto o tolto dopo aver visto un risultato.
|
||||
|
||||
ATTESE A PRIORI (dichiarate qui PRIMA di misurare; a fine script si dice confermata/refutata)
|
||||
=============================================================================================
|
||||
A1 Il paniere avra' Sharpe piu' alto di OGNI singola gamba. E' aritmetica di diversificazione,
|
||||
non evidenza: e' attesa, e da sola non decide niente.
|
||||
A2 Il DSR analitico del paniere si RIBALTA col conteggio dei trial (lezione 30/07 + §10/§24):
|
||||
PASS con N=K, FAIL con N=somma dei trial di famiglia. Verdetto pubblicato con la sensibilita'.
|
||||
A3 Il paniere dei QUASI-PASSATI battera' quello degli SCARTATI NETTI in-sample (per costruzione:
|
||||
i primi sono cellette scelte, i secondi no) MA il vantaggio si RIDURRA' sull'hold-out.
|
||||
A4 Le gambe sono quasi scorrelate fra loro -> ampiezza effettiva vicina a K -> il paniere alza
|
||||
lo Sharpe PER COSTRUZIONE senza contenere un solo edge nuovo.
|
||||
A5 Il paniere "funziona" grazie a UNA gamba (PREVDAY, il piu' forte misurato in §50) -> il
|
||||
leave-one-out lo mostrera'.
|
||||
A6 Almeno una gamba e' STAT-MODE (XSR01: venue diverso, non Deribit) -> il paniere COSI' COM'E'
|
||||
non e' un candidato al libro, a prescindere dal numero.
|
||||
A7 Le gambe sono DECADUTE dalla loro pubblicazione (i numeri hanno 1-2 mesi): mi aspetto un
|
||||
degrado, non un miglioramento.
|
||||
|
||||
METODO / VINCOLI
|
||||
================
|
||||
* SOLA LETTURA. Nessun file di produzione toccato, nessun ordine, nessuna chiave API.
|
||||
Endpoint di rete: NESSUNO (tutto da parquet certificati + cache su disco).
|
||||
* Le serie hanno date d'inizio diverse -> `combine_outer` con rinormalizzazione per riga, e la
|
||||
COPERTURA PER COLONNA e' STAMPATA (prima diagnostica di un outer-join: il progetto ha gia'
|
||||
pubblicato un muro sbagliato di 3x per averla saltata).
|
||||
* Lente Sharpe: `altlib._sh` (365,25 g/anno) ovunque, dichiarata.
|
||||
* Replica di un numero pubblicato PRIMA di produrne di nuovi (sezione 3).
|
||||
* Controllo positivo obbligatorio: un rilevatore che non trova nulla e' indistinguibile da uno
|
||||
rotto -> i null sono validati su casi in cui DEVONO scattare.
|
||||
|
||||
USO
|
||||
uv run python scripts/research/r0823b_quasi_passati.py [--draws 1000] [--force]
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import itertools
|
||||
import math
|
||||
import pickle
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path("/opt/docker/PythagorasGoal")
|
||||
for _p in (str(ROOT), str(ROOT / "scripts" / "research"),
|
||||
str(ROOT / "scripts" / "research" / "alt"),
|
||||
str(ROOT / "scripts" / "research" / "ortho")):
|
||||
if _p not in sys.path:
|
||||
sys.path.insert(0, _p)
|
||||
|
||||
# --- produzione (IMPORTATA, mai riscritta) ---------------------------------------------------
|
||||
from src.portfolio.portfolio import combine_outer, metrics # noqa: E402
|
||||
from src.live import book as LB # noqa: E402
|
||||
|
||||
# --- macchineria di ricerca gia' validata (riusata, non riscritta) ---------------------------
|
||||
import altlib as al # noqa: E402
|
||||
import ortholib as ol # noqa: E402
|
||||
import orthogonal_signals as OS # noqa: E402
|
||||
import r0823_prevday_gate as PG # noqa: E402 (factory + griglia 336)
|
||||
import r0730_vrp_tenor_gate as VT # noqa: E402 (cell_daily, griglia 72)
|
||||
import r0725_statarb_multi as SM # noqa: E402 (meccanismo XSR congelato)
|
||||
import r0725_statarb_basket_gate as BG # noqa: E402 (pair_frames / demean)
|
||||
from r0726_dvolspread_gate import make_book as dvs_make_book, GRID as DVS_GRID # noqa: E402
|
||||
|
||||
HOLDOUT = al.HOLDOUT
|
||||
SEED = 20260823
|
||||
T0 = time.time()
|
||||
|
||||
_SP = Path("/tmp/claude-1001/-opt-docker-PythagorasGoal/"
|
||||
"b6cc75e7-14f8-4c32-bd07-ab8a0d2aaee6/scratchpad/qp")
|
||||
SCRATCH = _SP if _SP.parent.parent.exists() else Path("/tmp/pythagoras_quasi")
|
||||
CACHE = SCRATCH / "families_v1.pkl"
|
||||
B3RD_CACHE = SCRATCH.parent / "b3rd" / "series_v3.pkl" # cache §50 (serie ancorate, funding IN)
|
||||
|
||||
CAPITAL_TODAY = 635.0
|
||||
MIN_ORDER = 5.0
|
||||
BOOK_START = pd.Timestamp("2019-03-14", tz="UTC")
|
||||
W_TP, W_SKH = LB.W_TP01, LB.W_SKH
|
||||
TP_HOURS = tuple(range(24))
|
||||
SKH_OFFSETS = tuple(range(0, 690, 30))
|
||||
XS_FUNDING_DRAG_YR = 0.0145 # §37, dichiarato (XS paga funding, non lo incassa)
|
||||
|
||||
# --- LE CELLE CONGELATE (rappresentanti dei 5 quasi-passati) ---------------------------------
|
||||
FROZEN = {
|
||||
"PREVDAY": dict(tf="1h", anchor=1, k=0.30, short=True, mh=0),
|
||||
"DVOLSPREAD": dict(zwin=180, tanh_k=2.0, lw=0.6, zw=1.1, tgt=0.17, svw=60),
|
||||
"DVS-PUB": dict(zwin=150, tanh_k=1.8, lw=0.45, zw=1.0, tgt=0.13, svw=50),
|
||||
"VRP-TENORE": dict(tenor=10, sd=-0.28, ld=-0.05),
|
||||
"STATARB": dict(W=45, sgn=+1),
|
||||
"XSR01": dict(W=45, sgn=+1),
|
||||
}
|
||||
LEGS = ["PREVDAY", "DVOLSPREAD", "VRP-TENORE", "STATARB", "XSR01"]
|
||||
|
||||
# --- trial DICHIARATI per famiglia, contati AL RIALZO (regola 30/07) -------------------------
|
||||
N_TRIALS = {"PREVDAY": 336, "DVOLSPREAD": 729, "VRP-TENORE": 72, "STATARB": 10, "XSR01": 10}
|
||||
|
||||
|
||||
def sez(t: str) -> None:
|
||||
print("\n" + "=" * 106)
|
||||
print(f" {t}")
|
||||
print("=" * 106)
|
||||
|
||||
|
||||
def sub(t: str) -> None:
|
||||
print("\n" + "-" * 106)
|
||||
print(f" {t}")
|
||||
print("-" * 106)
|
||||
|
||||
|
||||
def clock() -> str:
|
||||
return f"[{time.time() - T0:6.1f}s]"
|
||||
|
||||
|
||||
def sh(s) -> float:
|
||||
return al._sh(s)
|
||||
|
||||
|
||||
def shH(s) -> float:
|
||||
s = s[s.index >= HOLDOUT]
|
||||
return al._sh(s) if len(s) > 30 else float("nan")
|
||||
|
||||
|
||||
def shI(s) -> float:
|
||||
s = s[s.index < HOLDOUT]
|
||||
return al._sh(s) if len(s) > 30 else float("nan")
|
||||
|
||||
|
||||
def dd(s) -> float:
|
||||
return al._dd_ret(s)
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# LE FAMIGLIE — ogni cella e' una serie di rendimenti netti GIORNALIERI (fee reali, no funding)
|
||||
# =============================================================================================
|
||||
def fam_prevday() -> dict:
|
||||
out = {}
|
||||
for tf in PG.G_TF:
|
||||
for a, k, s_, mh in itertools.product(PG.G_ANCHOR, PG.G_K, PG.G_SHORT, PG.G_MH):
|
||||
key = (tf, a, k, s_, mh)
|
||||
try:
|
||||
fn = PG.factory(tf=tf, anchor=a, k=k, short=s_, mh=mh)
|
||||
out[key] = al.candidate_daily(fn, tf=tf)
|
||||
except Exception:
|
||||
continue
|
||||
return out
|
||||
|
||||
|
||||
def fam_dvolspread() -> dict:
|
||||
out = {}
|
||||
keys = list(DVS_GRID)
|
||||
for combo in itertools.product(*[DVS_GRID[k] for k in keys]):
|
||||
kw = dict(zip(keys, combo))
|
||||
try:
|
||||
out[tuple(kw[k] for k in keys)] = ol.eval_book(dvs_make_book(**kw))["daily"].dropna()
|
||||
except Exception:
|
||||
continue
|
||||
return out
|
||||
|
||||
|
||||
def fam_vrp() -> dict:
|
||||
out = {}
|
||||
for tn, sd_, ld in itertools.product(VT.TENORS, VT.SHORT_DELTAS, VT.LONG_DELTAS):
|
||||
try:
|
||||
s = VT.cell_daily(tn, sd_, ld)
|
||||
if len(s) > 200:
|
||||
out[(tn, sd_, ld)] = s
|
||||
except Exception:
|
||||
continue
|
||||
return out
|
||||
|
||||
|
||||
def _spread_daily(pos, j) -> pd.Series:
|
||||
ev = OS.eval_spread(j, pos)
|
||||
return pd.Series(ev["net"], index=pd.DatetimeIndex(pd.to_datetime(j["datetime"], utc=True)))
|
||||
|
||||
|
||||
def fam_statarb() -> dict:
|
||||
j = OS.build_joint("1d")
|
||||
out = {}
|
||||
for W, sg in itertools.product((30, 45, 60, 90, 120), (1, -1)):
|
||||
out[(W, sg)] = _spread_daily(OS.f_statarb_resid(W=W, sgn=sg)(j), j)
|
||||
return out
|
||||
|
||||
|
||||
def fam_xsr() -> dict:
|
||||
"""XSR01: meccanismo STATARB-RESID congelato sui 50 alt HL, posizioni DEMEANATE."""
|
||||
out = {}
|
||||
W0, S0 = SM.W, SM.SGN
|
||||
try:
|
||||
for W, sg in itertools.product((30, 45, 60, 90, 120), (1, -1)):
|
||||
SM.W, SM.SGN = W, sg
|
||||
P, S = BG.pair_frames()
|
||||
out[(W, sg)] = BG.basket_from_positions(P, S, demean=True)
|
||||
finally:
|
||||
SM.W, SM.SGN = W0, S0
|
||||
return out
|
||||
|
||||
|
||||
def fam_ortho_rejects() -> dict:
|
||||
"""B4 — SCARTATI NETTI CROSS-MECCANISMO: 4 famiglie relative-value dell'onda ortho
|
||||
(2026-06-21) che lo scorer INDURITO ha collassato (17/18 -> 1). Meccanismi DIVERSI fra loro
|
||||
e diversi dai quasi-passati. Stesso dato, stesse fee, stessa lente."""
|
||||
j = OS.build_joint("1d")
|
||||
out = {}
|
||||
for nm in ("RATIO-MOM", "RATIO-REV", "RATIO-ACCEL", "VOLSPREAD"):
|
||||
f, grid, _ = OS.FAMILIES[nm]
|
||||
out[nm] = {tuple(sorted(p.items())): _spread_daily(f(**p)(j), j) for p in grid}
|
||||
return out
|
||||
|
||||
|
||||
def build_families(force: bool) -> dict:
|
||||
if CACHE.exists() and not force:
|
||||
print(f" {clock()} cache famiglie: {CACHE}")
|
||||
return pickle.loads(CACHE.read_bytes())
|
||||
F = {}
|
||||
for nm, fn in (("VRP-TENORE", fam_vrp), ("STATARB", fam_statarb), ("XSR01", fam_xsr),
|
||||
("DVOLSPREAD", fam_dvolspread), ("PREVDAY", fam_prevday)):
|
||||
t = time.time()
|
||||
F[nm] = fn()
|
||||
print(f" {clock()} famiglia {nm:<12} {len(F[nm]):>4} celle ({time.time()-t:5.1f}s)")
|
||||
t = time.time()
|
||||
F["_ORTHO"] = fam_ortho_rejects()
|
||||
print(f" {clock()} famiglie ortho (controllo B4): "
|
||||
f"{ {k: len(v) for k, v in F['_ORTHO'].items()} } ({time.time()-t:.1f}s)")
|
||||
SCRATCH.mkdir(parents=True, exist_ok=True)
|
||||
CACHE.write_bytes(pickle.dumps(F))
|
||||
return F
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# MATRICE ALLINEATA + COMBINAZIONE EQUIPESATA (replica numerica di combine_outer)
|
||||
# =============================================================================================
|
||||
class Grid:
|
||||
"""Tutte le celle di tutte le famiglie su UN indice-unione. Il combinatore equipesato e'
|
||||
la trasposizione numpy di `combine_outer` (verificata bit-exact in sezione 5)."""
|
||||
|
||||
def __init__(self, fams: dict, lo=None):
|
||||
idx = None
|
||||
for f in fams.values():
|
||||
for s in f.values():
|
||||
idx = s.index if idx is None else idx.union(s.index)
|
||||
if lo is not None:
|
||||
idx = idx[idx >= lo]
|
||||
self.idx = idx
|
||||
self.cols, self.keys = {}, {}
|
||||
mats = []
|
||||
for nm, f in fams.items():
|
||||
ks = list(f)
|
||||
self.keys[nm] = ks
|
||||
M = np.full((len(idx), len(ks)), np.nan)
|
||||
for c, k in enumerate(ks):
|
||||
M[:, c] = f[k].reindex(idx).values
|
||||
self.cols[nm] = M
|
||||
mats.append(M)
|
||||
|
||||
def pick(self, sel: dict) -> np.ndarray:
|
||||
return np.column_stack([self.cols[nm][:, self.keys[nm].index(k)] for nm, k in sel.items()])
|
||||
|
||||
def combo(self, M: np.ndarray, idx=None) -> pd.Series:
|
||||
# `idx`: indice delle RIGHE di M. Default self.idx (M sull'intera unione);
|
||||
# va passato esplicitamente quando M e' un sottoinsieme di righe, altrimenti
|
||||
# la maschera `keep` e l'indice hanno lunghezze diverse.
|
||||
ix = self.idx if idx is None else idx
|
||||
if M.shape[0] != len(ix):
|
||||
raise ValueError(f"combo: M ha {M.shape[0]} righe, l'indice ne ha {len(ix)}")
|
||||
mask = ~np.isnan(M)
|
||||
w = mask.astype(float)
|
||||
rs = w.sum(axis=1, keepdims=True)
|
||||
wn = np.divide(w, rs, out=np.zeros_like(w), where=rs > 0)
|
||||
v = np.nansum(np.nan_to_num(M) * wn, axis=1)
|
||||
keep = mask.any(axis=1)
|
||||
return pd.Series(v[keep], index=ix[keep])
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 0) ATTESE | 1) CENSIMENTO | 2) REGOLA
|
||||
# =============================================================================================
|
||||
CENSIMENTO = [
|
||||
# nome, criterio, valore, soglia, distanza, esito, eseguibile, fonte
|
||||
("PREVDAY (cella viva)", "deflated-Sharpe N=336", 0.905, 0.95, -0.045, "FAIL",
|
||||
"SI' — Deribit, netta col libro", "RESULTS §54"),
|
||||
("DVOLSPREAD (congelata)", "deflated-Sharpe N=729", 0.953, 0.95, +0.003, "PASS di misura",
|
||||
"SI' — Deribit, netta col libro", "CLAUDE.md 26/07"),
|
||||
("DVOLSPREAD (pubblicata)", "deflated-Sharpe N=729", 0.947, 0.95, -0.003, "FAIL",
|
||||
"SI' — Deribit", "CLAUDE.md 26/07"),
|
||||
("VRP-TENORE 10g -0,28/-0,05", "deflated-Sharpe N=72", 0.948, 0.95, -0.002, "FAIL",
|
||||
"opzioni ETH, lotto ~$242", "CLAUDE.md 30/07"),
|
||||
("STATARB-RESID W45 sgn+1", "deflated-Sharpe same-sign", 0.929, 0.95, -0.021, "FAIL",
|
||||
"SI' — 2 gambe BTC/ETH", "diario 2026-06-29"),
|
||||
("XSR01 (50 alt HL, demean)", "weights_tilt_null delta_IS", -0.004, 0.0, -0.004, "FAIL",
|
||||
"NO — venue Hyperliquid, STAT-MODE", "CLAUDE.md 25/07"),
|
||||
]
|
||||
ESCLUSI = [
|
||||
("BIN-FREQ (SKH01)", "DSR 0,977 PASS ma 3 FAIL su 4 gambe del criterio",
|
||||
"non e' una gamba propria: e' una MODIFICA di uno sleeve in produzione (R3)"),
|
||||
("XS01-OOS", "DSR 0,342", "distanza 0,61 dalla soglia: e' uno scartato netto, non un quasi (R2)"),
|
||||
("STA05 (EWMA-cross)", "nessuna soglia numerica pubblicata",
|
||||
"mori' su hold-out corto + corr 0,53 a TP01, non su un gate a soglia (R2)"),
|
||||
("DVOL-DIREZIONALE", "is_hedge = True", "criterio BINARIO: non esiste una distanza (R2)"),
|
||||
("EW-STR (tilt di pesi)", "pctl 94-100 fra 500 tilt", "e' un cambio di PESI, non un candidato (R1)"),
|
||||
("LOWVOL 19-major", "DSR 0,13", "scartato netto (R2)"),
|
||||
]
|
||||
|
||||
|
||||
def sezione1() -> None:
|
||||
sez("1) CENSIMENTO DEI QUASI-PASSATI — criterio, valore, distanza dalla soglia")
|
||||
print(f" {'candidato':<28}{'criterio':<28}{'val':>8}{'soglia':>8}{'dist':>8} {'esito':<16}"
|
||||
f"{'eseguibile a $635'}")
|
||||
for nm, cr, v, so, di, es, ex, fo in CENSIMENTO:
|
||||
print(f" {nm:<28}{cr:<28}{v:>8.3f}{so:>8.2f}{di:>+8.3f} {es:<16}{ex}")
|
||||
print(f"\n {'':28}{'':28}{'':8}{'':8}{'':8} fonti: " +
|
||||
", ".join(sorted({f for *_, f in CENSIMENTO})))
|
||||
sub("ESCLUSI dal paniere, e perche' (la regola e' dichiarata PRIMA, non adattata all'esito)")
|
||||
for nm, dato, perche in ESCLUSI:
|
||||
print(f" {nm:<24} {dato:<44} -> {perche}")
|
||||
|
||||
|
||||
def sezione2() -> None:
|
||||
sez("2) REGOLA DI AMMISSIONE — dichiarata prima, NON cambiata dopo")
|
||||
print(" (R1) non e' nel libro live ne' nel book a 5 sleeve")
|
||||
print(" (R2) |DSR - 0,95| <= 0,05 OPPURE |delta_insample| <= 0,01 su weights_tilt_null")
|
||||
print(" (R3) serie ricostruibile da codice committato coi parametri congelati/pubblicati")
|
||||
print(" Rappresentante = la cella CONGELATA NEL MONITOR (o la pubblicata se monitor assente).")
|
||||
print(" PESI UGUALI. Nessuna selezione successiva. Il leave-one-out e' DIAGNOSTICA.")
|
||||
print(f"\n -> entrano {len(LEGS)} gambe: " + ", ".join(LEGS))
|
||||
print(" ⚠️ DVOLSPREAD: due celle difendibili (congelata 0,953 / pubblicata 0,947). La regola")
|
||||
print(" dice 'quella del monitor' = la CONGELATA; la pubblicata gira come SENSIBILITA'.")
|
||||
print(f"\n trial dichiarati per famiglia (al RIALZO, regola 30/07): {N_TRIALS}")
|
||||
print(f" SOMMA = {sum(N_TRIALS.values())} trial. E' questo il N del deflated-Sharpe del")
|
||||
print(" paniere, NON K=5: un paniere di K candidati gia' selezionati si porta dietro TUTTI")
|
||||
print(" i trial delle famiglie da cui vengono.")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 3) REPLICHE — un numero gia' pubblicato prima di produrne di nuovi
|
||||
# =============================================================================================
|
||||
def sezione3(F: dict) -> dict:
|
||||
sez("3) REPLICHE — riprodurre i numeri PUBBLICATI prima di produrne di nuovi")
|
||||
legs = {}
|
||||
legs["PREVDAY"] = F["PREVDAY"][("1h", 1, 0.30, True, 0)]
|
||||
kd = list(DVS_GRID)
|
||||
legs["DVOLSPREAD"] = F["DVOLSPREAD"][tuple(FROZEN["DVOLSPREAD"][k] for k in kd)]
|
||||
dvs_pub = F["DVOLSPREAD"][tuple(FROZEN["DVS-PUB"][k] for k in kd)]
|
||||
legs["VRP-TENORE"] = F["VRP-TENORE"][(10, -0.28, -0.05)]
|
||||
legs["STATARB"] = F["STATARB"][(45, 1)]
|
||||
legs["XSR01"] = F["XSR01"][(45, 1)]
|
||||
vrp_canon = F["VRP-TENORE"][(7, -0.28, -0.10)]
|
||||
pv_blind = F["PREVDAY"][("4h", 1, 0.30, False, 0)]
|
||||
|
||||
print(f" {'oggetto':<34}{'pubblicato':>26}{'ri-misurato oggi':>30} esito")
|
||||
rows = [
|
||||
("PREVDAY congelata FULL/HOLD (§54)", "1,236 / 1,297",
|
||||
f"{sh(legs['PREVDAY']):.3f} / {shH(legs['PREVDAY']):.3f}"),
|
||||
("PREVDAY al buio 4h FULL/HOLD (§54)", "1,621 / 0,731",
|
||||
f"{sh(pv_blind):.3f} / {shH(pv_blind):.3f}"),
|
||||
("DVOLSPREAD onesta FULL/HOLD (26/07)", "0,68 / 0,69", "vedi vintage sotto"),
|
||||
("VRP canonico 7g FULL (30/07)", "1,32", f"{sh(vrp_canon):.3f}"),
|
||||
("VRP 10g -0,28/-0,05 FULL (30/07)", "1,55", f"{sh(legs['VRP-TENORE']):.3f}"),
|
||||
]
|
||||
for a, b, c in rows:
|
||||
print(f" {a:<34}{b:>26}{c:>30} ")
|
||||
|
||||
sub("3b) LE GAMBE AL VINTAGE DELLA LORO PUBBLICAZIONE — la replica vera")
|
||||
print(" Ogni numero pubblicato ha una DATA. Confrontarlo con la serie di oggi non e' una")
|
||||
print(" replica: e' una replica PIU' un mese di dati nuovi. Qui si separano le due cose.")
|
||||
print(f"\n {'gamba':<22}{'vintage':>12}{'FULL pubbl.':>13}{'FULL vintage':>14}"
|
||||
f"{'FULL oggi':>11}{'HOLD pubbl.':>13}{'HOLD vintage':>14}{'HOLD oggi':>11}")
|
||||
vint = [("PREVDAY", "2026-08-23", "1,236", "1,297"),
|
||||
("DVOLSPREAD", "2026-07-26", "0,68", "0,69"),
|
||||
("DVS-PUB", "2026-07-26", "—", "0,93"),
|
||||
("VRP-TENORE", "2026-07-30", "1,55", "1,01"),
|
||||
("STATARB", "2026-06-29", "0,84", "—"),
|
||||
("XSR01", "2026-07-25", "1,82", "—")]
|
||||
rep = {}
|
||||
for nm, cut, pf, ph in vint:
|
||||
s = dvs_pub if nm == "DVS-PUB" else legs[nm]
|
||||
sv = s[s.index < cut]
|
||||
rep[nm] = (sh(sv), shH(sv), sh(s), shH(s))
|
||||
print(f" {nm:<22}{cut:>12}{pf:>13}{sh(sv):>14.3f}{sh(s):>11.3f}"
|
||||
f"{ph:>13}{shH(sv):>14.3f}{shH(s):>11.3f}")
|
||||
print("\n ✅ ogni cifra 'vintage' e' la replica del 'pubblicato' accanto (la colonna 'oggi'")
|
||||
print(" e' un numero NUOVO). Le due colonne insieme misurano il DECADIMENTO da allora.")
|
||||
dec = [(nm, rep[nm][0] - float(pf.replace(",", ".")))
|
||||
for nm, _, pf, _ in vint if pf != "—"]
|
||||
return dict(legs=legs, dvs_pub=dvs_pub, vrp_canon=vrp_canon, pv_blind=pv_blind, rep=rep)
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 4) CORRELAZIONI E AMPIEZZA EFFETTIVA — prima dei rendimenti, come chiede la domanda
|
||||
# =============================================================================================
|
||||
def eff_breadth(C: np.ndarray) -> float:
|
||||
n = len(C)
|
||||
off = C[~np.eye(n, dtype=bool)]
|
||||
rbar = float(np.nanmean(off))
|
||||
return n / (1.0 + (n - 1) * rbar) if rbar > -1.0 / (n - 1) else float(n)
|
||||
|
||||
|
||||
def sezione4(legs: dict) -> dict:
|
||||
sez("4) CORRELAZIONI E AMPIEZZA EFFETTIVA — misurate PRIMA dei rendimenti del paniere")
|
||||
print(" Se le gambe sono scorrelate, un paniere alza lo Sharpe PER COSTRUZIONE senza")
|
||||
print(" contenere un solo edge nuovo. Questa tabella e' il contesto di ogni numero dopo.")
|
||||
M = pd.concat(legs, axis=1, join="outer").sort_index()
|
||||
Ci = M.corr()
|
||||
print(f"\n matrice di correlazione (giorni in comune a coppie, no riempimento):\n")
|
||||
print(" " + " " * 13 + "".join(f"{c[:11]:>13}" for c in Ci.columns))
|
||||
for r in Ci.index:
|
||||
print(f" {r[:12]:<13}" + "".join(f"{Ci.loc[r, c]:>13.3f}" for c in Ci.columns))
|
||||
C = Ci.values
|
||||
off = C[~np.eye(len(C), dtype=bool)]
|
||||
nb = eff_breadth(C)
|
||||
print(f"\n corr media fuori diagonale = {np.nanmean(off):+.4f} "
|
||||
f"[min {np.nanmin(off):+.3f}, max {np.nanmax(off):+.3f}]")
|
||||
print(f" AMPIEZZA EFFETTIVA (N / (1+(N-1)·rbar), la formula gia' usata dal progetto in")
|
||||
print(f" r0725_statarb_basket_gate.eff_breadth) = {nb:.2f} su K = {len(C)} gambe.")
|
||||
print(f" -> il paniere vale, in termini di scommesse indipendenti, {nb:.2f} gambe.")
|
||||
tp = al.tp01_baseline_daily()
|
||||
print(f"\n correlazione di ogni gamba al baseline TP01 (il libro e' 75% TP01):")
|
||||
for k, s in legs.items():
|
||||
a, b = s.align(tp, join="inner")
|
||||
print(f" {k:<14}{a.corr(b):+.3f} (giorni comuni {len(a)})")
|
||||
return dict(corr=Ci, neff=nb)
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 5) IL PANIERE — copertura per colonna PRIMA di tutto
|
||||
# =============================================================================================
|
||||
def sezione5(G: Grid, legs: dict) -> dict:
|
||||
sez("5) IL PANIERE EQUIPESATO — e la sua COPERTURA PER COLONNA")
|
||||
sel = {"PREVDAY": ("1h", 1, 0.30, True, 0),
|
||||
"DVOLSPREAD": tuple(FROZEN["DVOLSPREAD"][k] for k in DVS_GRID),
|
||||
"VRP-TENORE": (10, -0.28, -0.05), "STATARB": (45, 1), "XSR01": (45, 1)}
|
||||
M = G.pick(sel)
|
||||
B = G.combo(M)
|
||||
|
||||
# --- bit-exact contro la produzione ------------------------------------------------------
|
||||
Bp = combine_outer({k: legs[k] for k in LEGS}, {k: 1.0 for k in LEGS}, lo=G.idx[0])
|
||||
a, b = B.align(Bp, join="outer")
|
||||
mx = float(np.nanmax(np.abs(a.fillna(0) - b.fillna(0))))
|
||||
print(f" ✅ combinatore numpy == `combine_outer` di produzione: max|diff| = {mx:.3e} "
|
||||
f"(n {len(B)} vs {len(Bp)})")
|
||||
|
||||
sub("5a) COPERTURA PER COLONNA — la prima diagnostica di un outer-join")
|
||||
print(" Il progetto ha gia' pubblicato un muro sbagliato di 3x per aver saltato questa")
|
||||
print(" tabella (r0726_wall_fixedpoint: una colonna al 100% accanto a colonne basse).")
|
||||
print(f"\n {'gamba':<14}{'primo giorno':>14}{'giorni':>9}{'copertura':>11}"
|
||||
f"{'barre ATTIVE':>14}{'attive/cal.':>12}")
|
||||
cov = {}
|
||||
for i, nm in enumerate(LEGS):
|
||||
col = M[:, i]
|
||||
n_ok = int(np.sum(~np.isnan(col)))
|
||||
act = int(np.sum(np.nan_to_num(col) != 0.0))
|
||||
first = G.idx[np.argmax(~np.isnan(col))]
|
||||
cov[nm] = n_ok / len(G.idx)
|
||||
print(f" {nm:<14}{str(first.date()):>14}{n_ok:>9}{n_ok/len(G.idx):>10.1%}"
|
||||
f"{act:>14}{act/max(1,n_ok):>12.1%}")
|
||||
print(f" {'UNIONE':<14}{str(G.idx[0].date()):>14}{len(G.idx):>9}{1.0:>10.1%}")
|
||||
n_legs = (~np.isnan(M)).sum(axis=1)
|
||||
print(f"\n gambe VIVE per giorno: " +
|
||||
" ".join(f"{k}: {100*np.mean(n_legs==k):.1f}%" for k in range(1, 6)))
|
||||
print(" 🚨 il paniere e' a 5 gambe solo nel " f"{100*np.mean(n_legs==5):.1f}% dei giorni: "
|
||||
"prima del 2024 XSR01 non esiste, prima del 2021 nemmeno VRP.")
|
||||
print(" ⚠️ e la colonna 'attive/cal.' dice un'altra cosa ancora: DVOLSPREAD e VRP hanno")
|
||||
print(" zeri STRUTTURALI (flat senza DVOL / settimanale su griglia giornaliera) -> un")
|
||||
print(" giorno presente non e' un giorno di rischio (lezione 'barre attive', 26/07).")
|
||||
|
||||
common = G.idx[n_legs == 5]
|
||||
Bc = G.combo(M[(n_legs == 5), :], common) if len(common) > 60 else None
|
||||
|
||||
sub("5b) METRICHE DEL PANIERE — due lenti dichiarate")
|
||||
print(f" {'lente':<28}{'n':>7}{'ShFULL':>9}{'ShIS':>9}{'ShHOLD':>9}{'CAGR':>9}{'maxDD':>9}")
|
||||
for nm, s in (("UNIONE (rinormalizzata)", B), ("FINESTRA COMUNE (5/5 gambe)", Bc)):
|
||||
if s is None:
|
||||
continue
|
||||
m = metrics(s)
|
||||
print(f" {nm:<28}{len(s):>7}{sh(s):>9.3f}{shI(s):>9.3f}{shH(s):>9.3f}"
|
||||
f"{100*m['cagr']:>8.2f}%{100*m['maxdd']:>8.2f}%")
|
||||
print(f"\n {'gamba sola':<28}{'n':>7}{'ShFULL':>9}{'ShIS':>9}{'ShHOLD':>9}{'CAGR':>9}{'maxDD':>9}")
|
||||
for nm in LEGS:
|
||||
s = legs[nm]
|
||||
m = metrics(s)
|
||||
print(f" {nm:<28}{len(s):>7}{sh(s):>9.3f}{shI(s):>9.3f}{shH(s):>9.3f}"
|
||||
f"{100*m['cagr']:>8.2f}%{100*m['maxdd']:>8.2f}%")
|
||||
print(f"\n A1: il paniere batte OGNI gamba sul FULL? "
|
||||
f"{'SI' if sh(B) > max(sh(legs[n]) for n in LEGS) else 'NO'} "
|
||||
f"(paniere {sh(B):.3f} vs miglior gamba {max(sh(legs[n]) for n in LEGS):.3f})")
|
||||
|
||||
sub("5c) PER ANNO — dove sta il rendimento del paniere")
|
||||
yr = {}
|
||||
for y, g in B.groupby(B.index.year):
|
||||
yr[y] = (sh(g), float(np.prod(1 + g.values) - 1), len(g))
|
||||
print(f" {'anno':>6}{'Sharpe':>10}{'ritorno':>11}{'giorni':>9} gambe vive (media)")
|
||||
for y in sorted(yr):
|
||||
mm = (G.idx.year == y)
|
||||
print(f" {y:>6}{yr[y][0]:>10.2f}{100*yr[y][1]:>10.1f}%{yr[y][2]:>9}"
|
||||
f" {n_legs[mm].mean():.2f}")
|
||||
|
||||
sub("5d) MARGINALE vs TP01 (lo scorer indurito del progetto, non riscritto)")
|
||||
mg = al.marginal_vs_tp01(B)
|
||||
for k in ("verdict", "corr_full", "corr_hold", "alpha_ann", "beta", "has_insample_edge",
|
||||
"is_hedge", "robust_oos", "beats_noise_null", "uplift_full_w25", "uplift_hold_w25"):
|
||||
if k in mg:
|
||||
print(f" {k:<22}{mg[k]}")
|
||||
return dict(B=B, Bc=Bc, sel=sel, M=M, cov=cov, n_legs=n_legs, marg=mg)
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 6) IL CONTO DEI TRIAL — DSR analitico a piu' partizioni + sensibilita'
|
||||
# =============================================================================================
|
||||
def dsr_of(series: pd.Series, trials: list[float]) -> tuple[float, float, float]:
|
||||
d, sr0 = al.deflated_sharpe(sh(series), trials, series)
|
||||
return d, sr0, float(np.std(np.asarray(trials, float), ddof=1)) / math.sqrt(365.25)
|
||||
|
||||
|
||||
def sezione6(F: dict, R5: dict, legs: dict) -> dict:
|
||||
sez("6) IL CONTO DEI TRIAL — deflated-Sharpe del PANIERE, e la sua sensibilita'")
|
||||
B = R5["B"]
|
||||
fam_full = {nm: [sh(s) for s in F[nm].values()] for nm in LEGS}
|
||||
pooled = [x for nm in LEGS for x in fam_full[nm]]
|
||||
print(f" Sharpe FULL del paniere = {sh(B):.4f}")
|
||||
print(f"\n {'partizione':<52}{'N':>7}{'sd(trial)/g':>13}{'null max Sh':>13}{'DSR':>8} esito")
|
||||
parts = [
|
||||
("P1 N = K (le 5 gambe) — SBAGLIATA, la riporto per taratura",
|
||||
[sh(legs[n]) for n in LEGS]),
|
||||
("P2 N = somma dei trial delle famiglie (la regola del brief)", pooled),
|
||||
("P3 N = famiglia PIU' LARGA sola (DVOLSPREAD 729)", fam_full["DVOLSPREAD"]),
|
||||
("P4 N = pooled + screen d'ondata (+168 ORTHO-SCREEN)",
|
||||
pooled + [sh(s) for f in F["_ORTHO"].values() for s in f.values()]),
|
||||
("P5 N = solo le 5 celle scelte, varianza di famiglia pooled",
|
||||
list(np.random.default_rng(1).choice(pooled, size=5, replace=False))),
|
||||
]
|
||||
out = {}
|
||||
for nm, tr in parts:
|
||||
d, sr0, sdt = dsr_of(B, tr)
|
||||
out[nm] = d
|
||||
print(f" {nm:<52}{len(tr):>7}{sdt:>13.5f}{sr0:>13.3f}{d:>8.3f} "
|
||||
f"{'PASS' if d >= 0.95 else 'FAIL'}")
|
||||
print("\n 🚨 Il verdetto NON e' stabile: cambia con la partizione, come il progetto ha gia'")
|
||||
print(" misurato il 30/07 (VRP: 0,983 PASS a N=8 / 0,948 FAIL a N=72 / 0,909 a N=360) e")
|
||||
print(" il 22/08 (§24: la stessa griglia da' verdetti opposti a seconda di come si parte).")
|
||||
print(" 📌 E c'e' un difetto STRUTTURALE piu' grave, che vale la pena dire in chiaro:")
|
||||
print(" `deflated_sharpe` stima il massimo-dal-rumore dalla varianza degli Sharpe dei")
|
||||
print(" TRIAL SINGOLI. Un PANIERE non e' un trial singolo: ha Sharpe piu' alto per pura")
|
||||
print(" diversificazione. Confrontarlo con una sr0 tarata su celle singole lo FAVORISCE")
|
||||
print(" sistematicamente -> il DSR analitico di un paniere e' OTTIMISTA a ogni N.")
|
||||
print(" Il test giusto e' EMPIRICO: la distribuzione dei PANIERI (sezione 7).")
|
||||
# sensibilita': quale sd(trial) ribalta il verdetto
|
||||
lo, hi = 1e-4, 1.0
|
||||
for _ in range(60):
|
||||
mid = 0.5 * (lo + hi)
|
||||
scaled = list(np.asarray(pooled) * (mid / (np.std(pooled, ddof=1) / math.sqrt(365.25)))
|
||||
) if np.std(pooled, ddof=1) > 0 else pooled
|
||||
d, _, _ = dsr_of(B, scaled)
|
||||
if d >= 0.95:
|
||||
lo = mid
|
||||
else:
|
||||
hi = mid
|
||||
print(f"\n sensibilita': con N={len(pooled)} il verdetto si ribalta a "
|
||||
f"sd(trial giornaliera) = {0.5*(lo+hi):.5f}; misurata = "
|
||||
f"{np.std(pooled, ddof=1)/math.sqrt(365.25):.5f}.")
|
||||
return out
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 7) IL CONTROLLO — CIO' CHE DECIDE
|
||||
# =============================================================================================
|
||||
def sezione7(F: dict, G: Grid, R5: dict, draws: int) -> dict:
|
||||
sez("7) IL CONTROLLO — panieri di SCARTATI NETTI. E' QUESTO IL TEST, non lo Sharpe del paniere")
|
||||
B = R5["B"]
|
||||
rng = np.random.default_rng(SEED)
|
||||
real = (sh(B), shI(B), shH(B), dd(B))
|
||||
|
||||
# in-sample ranking per famiglia (mai l'hold-out: sarebbe selection-on-holdout)
|
||||
rank = {}
|
||||
for nm in LEGS:
|
||||
ks = G.keys[nm]
|
||||
vals = np.array([shI(F[nm][k]) for k in ks])
|
||||
rank[nm] = dict(keys=ks, ins=vals, order=np.argsort(np.nan_to_num(vals, nan=-9)))
|
||||
frozen_idx = {nm: G.keys[nm].index(R5["sel"][nm]) for nm in LEGS}
|
||||
print(" rango IN-SAMPLE della cella congelata dentro la propria famiglia "
|
||||
"(mai l'hold-out: sarebbe selection-on-holdout)")
|
||||
for nm in LEGS:
|
||||
o = list(rank[nm]["order"][::-1])
|
||||
r = o.index(frozen_idx[nm]) + 1
|
||||
print(f" {nm:<14}{r:>4} / {len(o):<5} (pctl in-sample "
|
||||
f"{100*(1-(r-1)/len(o)):.0f}°, ShIS {rank[nm]['ins'][frozen_idx[nm]]:+.3f})")
|
||||
|
||||
def draw_basket(picker) -> tuple:
|
||||
cols = []
|
||||
for nm in LEGS:
|
||||
cols.append(G.cols[nm][:, picker(nm)])
|
||||
M = np.column_stack(cols)
|
||||
s = G.combo(M)
|
||||
return sh(s), shI(s), shH(s), dd(s)
|
||||
|
||||
def bottom(nm):
|
||||
o = rank[nm]["order"] # crescente: i primi sono i peggiori in-sample
|
||||
return int(rng.choice(o[:max(1, len(o) // 2)]))
|
||||
|
||||
def matched(nm):
|
||||
o = list(rank[nm]["order"][::-1])
|
||||
r = o.index(frozen_idx[nm]) / max(1, len(o) - 1)
|
||||
cand = [i for i in range(len(o)) if abs(i / max(1, len(o) - 1) - r) <= 0.10]
|
||||
return int(o[int(rng.choice(cand))])
|
||||
|
||||
def anyc(nm):
|
||||
return int(rng.integers(len(G.keys[nm])))
|
||||
|
||||
res = {}
|
||||
for tag, pick in (("B1 SCARTATI NETTI (meta' peggiore in-sample, stesse famiglie)", bottom),
|
||||
("B2 RANGO APPAIATO (stesso pctl in-sample +-10pp)", matched),
|
||||
("B0 CELLA A CASO (qualunque cella della famiglia)", anyc)):
|
||||
t = time.time()
|
||||
arr = np.array([draw_basket(pick) for _ in range(draws)])
|
||||
res[tag] = arr
|
||||
print(f"\n {tag} ({draws} panieri, {time.time()-t:.1f}s)")
|
||||
print(f" {'metrica':<10}{'reale':>9}{'p10':>9}{'mediana':>9}{'p90':>9}{'max':>9}"
|
||||
f"{'pctl del reale':>17}")
|
||||
for i, mn in enumerate(("ShFULL", "ShIS", "ShHOLD", "maxDD")):
|
||||
c = arr[:, i]
|
||||
pc = 100.0 * float((c < real[i]).mean())
|
||||
print(f" {mn:<10}{real[i]:>9.3f}{np.percentile(c,10):>9.3f}"
|
||||
f"{np.median(c):>9.3f}{np.percentile(c,90):>9.3f}{np.max(c):>9.3f}"
|
||||
f"{pc:>16.1f}°")
|
||||
|
||||
# --- B3: null di diversificazione (marginali CONSERVATE, correlazione distrutta) ----------
|
||||
sub("B3 NULL DI DIVERSIFICAZIONE — stesse gambe, correlazione incrociata DISTRUTTA")
|
||||
print(" Ogni gamba viene ruotata circolarmente di un lag casuale >= 60 giorni: lo Sharpe")
|
||||
print(" MARGINALE di ciascuna resta IDENTICO, sparisce solo la relazione fra gambe (e con")
|
||||
print(" TP01). Se il paniere reale non batte questa distribuzione, non contiene nulla oltre")
|
||||
print(" a 'K serie con quei marginali, quasi scorrelate'. Turnover invariato -> fee-neutrale.")
|
||||
M0 = R5["M"]
|
||||
arr = []
|
||||
for _ in range(draws):
|
||||
cols = []
|
||||
for i in range(M0.shape[1]):
|
||||
col = M0[:, i]
|
||||
ok = ~np.isnan(col)
|
||||
v = col[ok].copy()
|
||||
v = np.roll(v, int(rng.integers(60, max(61, len(v) - 60))))
|
||||
nc = np.full_like(col, np.nan)
|
||||
nc[ok] = v
|
||||
cols.append(nc)
|
||||
s = G.combo(np.column_stack(cols))
|
||||
arr.append((sh(s), shI(s), shH(s), dd(s)))
|
||||
arr = np.array(arr)
|
||||
res["B3"] = arr
|
||||
print(f"\n {'metrica':<10}{'reale':>9}{'p10':>9}{'mediana':>9}{'p90':>9}{'max':>9}"
|
||||
f"{'pctl del reale':>17}")
|
||||
for i, mn in enumerate(("ShFULL", "ShIS", "ShHOLD", "maxDD")):
|
||||
c = arr[:, i]
|
||||
print(f" {mn:<10}{real[i]:>9.3f}{np.percentile(c,10):>9.3f}{np.median(c):>9.3f}"
|
||||
f"{np.percentile(c,90):>9.3f}{np.max(c):>9.3f}"
|
||||
f"{100.0*float((c<real[i]).mean()):>16.1f}°")
|
||||
|
||||
# --- B4: cross-meccanismo, scartati netti veri --------------------------------------------
|
||||
sub("B4 SCARTATI NETTI CROSS-MECCANISMO — 4 famiglie relative-value refutate dall'onda ortho")
|
||||
print(" RATIO-MOM / RATIO-REV / RATIO-ACCEL / VOLSPREAD: meccanismi DIVERSI fra loro e dai")
|
||||
print(" quasi-passati, tutti collassati dallo scorer indurito (17/18 -> 1, 21/06). Stessa")
|
||||
print(" selezione dei quasi-passati (miglior cella IN-SAMPLE di ogni famiglia) + estrazioni.")
|
||||
OF = F["_ORTHO"]
|
||||
Go = Grid(OF)
|
||||
best = {}
|
||||
for nm, f in OF.items():
|
||||
ks = list(f)
|
||||
best[nm] = ks[int(np.argmax([np.nan_to_num(shI(f[k]), nan=-9) for k in ks]))]
|
||||
Mb = Go.pick(best)
|
||||
Bo = Go.combo(Mb)
|
||||
print(f"\n paniere dei 4 SCARTATI NETTI, celle scelte in-sample: ShFULL {sh(Bo):+.3f} "
|
||||
f"ShIS {shI(Bo):+.3f} ShHOLD {shH(Bo):+.3f} maxDD {100*dd(Bo):.1f}% n {len(Bo)}")
|
||||
Cb = pd.concat({k: OF[k][v] for k, v in best.items()}, axis=1).corr().values
|
||||
print(f" corr media fuori diagonale {np.nanmean(Cb[~np.eye(len(Cb),dtype=bool)]):+.3f} -> "
|
||||
f"ampiezza effettiva {eff_breadth(Cb):.2f} su 4")
|
||||
arr = []
|
||||
for _ in range(draws):
|
||||
s = Go.combo(np.column_stack([Go.cols[nm][:, int(rng.integers(len(Go.keys[nm])))]
|
||||
for nm in OF]))
|
||||
arr.append((sh(s), shI(s), shH(s), dd(s)))
|
||||
arr = np.array(arr)
|
||||
res["B4"] = arr
|
||||
print(f"\n {draws} panieri a cella casuale dalle stesse 4 famiglie refutate:")
|
||||
print(f" {'metrica':<10}{'quasi-pass.':>13}{'p10':>9}{'mediana':>9}{'p90':>9}{'max':>9}"
|
||||
f"{'pctl dei quasi':>17}")
|
||||
for i, mn in enumerate(("ShFULL", "ShIS", "ShHOLD", "maxDD")):
|
||||
c = arr[:, i]
|
||||
print(f" {mn:<10}{real[i]:>13.3f}{np.percentile(c,10):>9.3f}{np.median(c):>9.3f}"
|
||||
f"{np.percentile(c,90):>9.3f}{np.max(c):>9.3f}"
|
||||
f"{100.0*float((c<real[i]).mean()):>16.1f}°")
|
||||
|
||||
# --- CONTROLLO POSITIVO -------------------------------------------------------------------
|
||||
sub("CONTROLLO POSITIVO — un rilevatore che non segnala e' indistinguibile da uno rotto")
|
||||
print(" Se il confronto 'reale vs panieri casuali' avesse potenza ZERO, tutto quanto sopra")
|
||||
print(" sarebbe privo di significato. Lo si prova costruendo un paniere che DEVE stare in")
|
||||
print(" cima: la MIGLIOR cella in-sample di ognuna delle 5 famiglie.")
|
||||
bestQ = {}
|
||||
for nm in LEGS:
|
||||
o = rank[nm]["order"]
|
||||
bestQ[nm] = G.keys[nm][int(o[-1])]
|
||||
Bb = G.combo(G.pick(bestQ))
|
||||
B0 = res["B0 CELLA A CASO (qualunque cella della famiglia)"]
|
||||
pIS = 100.0 * float((B0[:, 1] < shI(Bb)).mean())
|
||||
print(f" paniere 'migliori in-sample': ShIS {shI(Bb):+.3f} -> pctl {pIS:.1f}deg della")
|
||||
print(f" distribuzione B0 (atteso ~100deg se il test ha potenza: e' il massimo per")
|
||||
print(f" costruzione, quindi un pctl basso significherebbe rilevatore ROTTO).")
|
||||
print(f" Il suo ShHOLD e' {shH(Bb):+.3f} contro mediana B0 {np.median(B0[:,2]):+.3f}:")
|
||||
print(f" e' QUESTO il pezzo di scelta in-sample che sopravvive fuori campione.")
|
||||
if pIS < 90.0:
|
||||
print(" RILEVATORE SOSPETTO: il paniere costruito per stare in cima NON ci sta.")
|
||||
return dict(res=res, real=real, best_is=Bb, ortho=Bo, rank=rank, frozen_idx=frozen_idx)
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 8) LEAVE-ONE-OUT
|
||||
# =============================================================================================
|
||||
def sezione8(G: Grid, R5: dict) -> dict:
|
||||
sez("8) LEAVE-ONE-OUT — se il paniere 'funziona' grazie a UNA gamba, non e' un paniere")
|
||||
B = R5["B"]
|
||||
base = (sh(B), shI(B), shH(B), dd(B))
|
||||
print(f" paniere completo: ShFULL {base[0]:.3f} ShIS {base[1]:.3f} ShHOLD {base[2]:.3f} "
|
||||
f"maxDD {100*base[3]:.2f}%")
|
||||
print(f"\n {'tolta':<14}{'ShFULL':>9}{'dShFULL':>10}{'ShHOLD':>9}{'dShHOLD':>10}"
|
||||
f"{'maxDD':>9}{'d maxDD pp':>12}")
|
||||
out = {}
|
||||
for nm in LEGS:
|
||||
keep = [k for k in LEGS if k != nm]
|
||||
s = G.combo(G.pick({k: R5["sel"][k] for k in keep}))
|
||||
out[nm] = (sh(s), shH(s), dd(s))
|
||||
print(f" {nm:<14}{sh(s):>9.3f}{sh(s)-base[0]:>+10.3f}{shH(s):>9.3f}"
|
||||
f"{shH(s)-base[2]:>+10.3f}{100*dd(s):>8.2f}%{100*(dd(s)-base[3]):>+12.2f}")
|
||||
worst = min(out, key=lambda k: out[k][0])
|
||||
print(f"\n la gamba il cui ritiro costa di piu' sul FULL: {worst} "
|
||||
f"({out[worst][0]-base[0]:+.3f})")
|
||||
return out
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 9) IL PANIERE COME TERZO SLEEVE DEL LIBRO LIVE — banda d'ancora, funding dentro
|
||||
# =============================================================================================
|
||||
def sezione9(R5: dict, legs: dict, draws: int) -> dict:
|
||||
sez("9) IL PANIERE COME TERZO SLEEVE DEL LIBRO LIVE — e batte la sua MIGLIOR gamba?")
|
||||
if not B3RD_CACHE.exists():
|
||||
print(f" ⚠️ cache §50 assente ({B3RD_CACHE}) -> sezione SALTATA. Non e' un risultato.")
|
||||
return {}
|
||||
S = pickle.loads(B3RD_CACHE.read_bytes())
|
||||
print(f" cache §50 riusata (serie ancorate, FUNDING DENTRO): {list(S)[:8]}...")
|
||||
|
||||
# replica del baseline §50 prima di ogni delta
|
||||
rng = np.random.default_rng(SEED)
|
||||
hs = rng.choice(TP_HOURS, size=draws)
|
||||
os_ = rng.choice(SKH_OFFSETS, size=draws)
|
||||
hs_sa = rng.choice(TP_HOURS, size=draws)
|
||||
base, dPV, dBK, dBK4 = [], [], [], []
|
||||
# gambe funding-consistenti: PREVDAY/STATARB/DVOLSPREAD dalla cache §50 (funding dentro),
|
||||
# VRP (opzioni: nessun funding di perp) e XSR01 con il drag dichiarato di §37.
|
||||
xsr = legs["XSR01"] - XS_FUNDING_DRAG_YR / 365.25
|
||||
vrp = legs["VRP-TENORE"]
|
||||
W_CAND = 0.15
|
||||
for i in range(draws):
|
||||
c2 = {"TP01": S["TP01"][hs[i]], "SKH01": S["SKH01"][os_[i]]}
|
||||
b = combine_outer(c2, {"TP01": W_TP, "SKH01": W_SKH}, lo=BOOK_START)
|
||||
mb, mbh = metrics(b), metrics(b[b.index >= HOLDOUT])
|
||||
base.append((mb["sharpe"], mbh["sharpe"], mb["maxdd"]))
|
||||
pan = combine_outer({"PREVDAY": S["PREVDAY"][0], "DVOLSPREAD": S["DVOLSPREAD"][0],
|
||||
"VRP-TENORE": vrp, "STATARB": S["STATARB"][hs_sa[i]], "XSR01": xsr},
|
||||
{k: 1.0 for k in LEGS}, lo=BOOK_START)
|
||||
pan4 = combine_outer({"PREVDAY": S["PREVDAY"][0], "DVOLSPREAD": S["DVOLSPREAD"][0],
|
||||
"VRP-TENORE": vrp, "STATARB": S["STATARB"][hs_sa[i]]},
|
||||
{k: 1.0 for k in LEGS if k != "XSR01"}, lo=BOOK_START)
|
||||
for tgt, lst in ((S["PREVDAY"][0], dPV), (pan, dBK), (pan4, dBK4)):
|
||||
c3 = dict(c2); c3["CAND"] = tgt
|
||||
a = combine_outer(c3, {"TP01": W_TP * (1 - W_CAND), "SKH01": W_SKH * (1 - W_CAND),
|
||||
"CAND": W_CAND}, lo=BOOK_START)
|
||||
ma, mah = metrics(a), metrics(a[a.index >= HOLDOUT])
|
||||
lst.append((ma["sharpe"] - mb["sharpe"], mah["sharpe"] - mbh["sharpe"],
|
||||
ma["maxdd"] - mb["maxdd"]))
|
||||
Bs = np.array(base)
|
||||
print(f"\n LIBRO LIVE de-luckato (2 sleeve, funding dentro), {draws} estrazioni:")
|
||||
print(f" ShFULL {np.median(Bs[:,0]):.3f} ShHOLD {np.median(Bs[:,1]):.3f} "
|
||||
f"maxDD {100*np.median(Bs[:,2]):.2f}%")
|
||||
print(" §50 pubblicava 1,813 / 1,437 / 9,42% -> ✅ replica (estrazioni diverse, "
|
||||
"stessa cache)")
|
||||
print(f"\n peso del candidato = {W_CAND:.0%}. Statistica = MEDIANA DELLE DIFFERENZE APPAIATE.")
|
||||
print(f"\n {'candidato':<34}{'dShFULL':>11}{'>0':>7}{'dShHOLD':>11}{'>0':>7}"
|
||||
f"{'d maxDD pp':>13}")
|
||||
rows = [("PREVDAY da sola (§50: +0,192/+0,363)", np.array(dPV)),
|
||||
("PANIERE 5 gambe (quasi-passati)", np.array(dBK)),
|
||||
("PANIERE 4 gambe (senza XSR01, eseguibile)", np.array(dBK4))]
|
||||
for nm, a in rows:
|
||||
print(f" {nm:<34}{np.median(a[:,0]):>+11.4f}{100*(a[:,0]>0).mean():>6.0f}%"
|
||||
f"{np.median(a[:,1]):>+11.4f}{100*(a[:,1]>0).mean():>6.0f}%"
|
||||
f"{100*np.median(a[:,2]):>+13.2f}")
|
||||
d5 = np.array(dBK)[:, 0] - np.array(dPV)[:, 0]
|
||||
d5h = np.array(dBK)[:, 1] - np.array(dPV)[:, 1]
|
||||
print(f"\n 🚨 PANIERE meno PREVDAY-DA-SOLA (differenza APPAIATA sulla stessa estrazione):")
|
||||
print(f" dShFULL {np.median(d5):+.4f} (>0 nel {100*(d5>0).mean():.0f}%) "
|
||||
f"dShHOLD {np.median(d5h):+.4f} (>0 nel {100*(d5h>0).mean():.0f}%)")
|
||||
return dict(base=Bs, dPV=np.array(dPV), dBK=np.array(dBK), dBK4=np.array(dBK4))
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# 10) ESEGUIBILITA' + EUR/GIORNO
|
||||
# =============================================================================================
|
||||
def sezione10(R5: dict, R9: dict) -> None:
|
||||
sez("10) ESEGUIBILITA' RIGA PER RIGA — un paniere con dentro uno STAT-MODE non e' un candidato")
|
||||
print(f" {'gamba':<14}{'venue':<14}{'su Deribit?':<14}{'ticket a $635 (peso 15%/5)':<30}"
|
||||
f"{'stato'}")
|
||||
tick = CAPITAL_TODAY * 0.15 / len(LEGS)
|
||||
righe = [
|
||||
("PREVDAY", "Deribit", "SI'", f"${tick:.2f} netta col libro", "eseguibile"),
|
||||
("DVOLSPREAD", "Deribit", "SI'", f"${tick:.2f} netta col libro", "eseguibile"),
|
||||
("STATARB", "Deribit", "SI'", f"${tick:.2f} netta col libro", "eseguibile"),
|
||||
("VRP-TENORE", "Deribit opz.", "SI' (ETH)", "1 lotto ETH = $242 (>> $19)",
|
||||
"🚨 NON eseguibile al peso"),
|
||||
("XSR01", "Hyperliquid", "NO", "50 gambe, min $10/gamba",
|
||||
"🚨 STAT-MODE, venue diverso"),
|
||||
]
|
||||
for r in righe:
|
||||
print(f" {r[0]:<14}{r[1]:<14}{r[2]:<14}{r[3]:<30}{r[4]}")
|
||||
print(f"\n 🚨 2 gambe su 5 NON sono eseguibili a $635 -> il paniere COSI' COM'E' non e' un")
|
||||
print(" candidato al libro, a prescindere da qualunque numero delle sezioni precedenti.")
|
||||
print(" VRP-TENORE cade sul LOTTO (regola gia' scritta: 'niente short-vol da modello in")
|
||||
print(" deploy' — il lotto non e' nemmeno il vincolo principale). XSR01 cade sul VENUE,")
|
||||
print(" e la decisione d'operatore tiene tutto su Deribit fino a $20k.")
|
||||
if R9:
|
||||
d = R9["dBK4"][:, 0]
|
||||
print(f"\n Il paniere ESEGUIBILE (4 gambe, senza XSR01) vale dShFULL "
|
||||
f"{np.median(d):+.4f} di libro. Per convertirlo in reddito serve la LEVA, che "
|
||||
f"a $635 non c'e'.")
|
||||
|
||||
|
||||
def eur_al_giorno(R9: dict) -> None:
|
||||
sez("11) IN EURO AL GIORNO — l'unita' che il progetto usa per non mentirsi")
|
||||
cagr_base = 0.1519 # L3 congiunta (fisco + funding), CLAUDE.md §36
|
||||
perp = 0.0635 # rendita perpetua L3
|
||||
print(f" Conto reale $635. Rendita perpetua della lente congiunta L3 = {100*perp:.2f}%/anno")
|
||||
print(f" -> oggi il libro vale ${635*perp/365.25:.3f}/giorno = "
|
||||
f"€{635*perp/365.25*0.92:.3f}/giorno.")
|
||||
if not R9:
|
||||
return
|
||||
d = np.median(R9["dBK4"][:, 0])
|
||||
dPV = np.median(R9["dPV"][:, 0])
|
||||
print(f"\n Il paniere eseguibile aggiunge dShFULL {d:+.4f} al libro; PREVDAY DA SOLA "
|
||||
f"{dPV:+.4f}.")
|
||||
print(" Uno dSharpe NON e' reddito a nozionale invariato (regola 25/07: un diversificatore")
|
||||
print(" a basso CAGR si giudica a ISO-RISCHIO). Convertito a iso-rischio con la leva che a")
|
||||
print(" $635 NON esiste, e prendendo per buono il d drift misurato in sezione 9:")
|
||||
dd_ = np.median(R9["dBK4"][:, 2])
|
||||
print(f" d maxDD {100*dd_:+.2f}pp -> a iso-DD si potrebbe alzare la scala di un fattore")
|
||||
print(f" ~{(np.median(R9['base'][:,2])/max(1e-9, np.median(R9['base'][:,2])+dd_)):.3f}, "
|
||||
f"cioe' ~{100*((np.median(R9['base'][:,2])/max(1e-9,np.median(R9['base'][:,2])+dd_))-1):.1f}% "
|
||||
f"di reddito in piu'.")
|
||||
v = 635 * perp / 365.25 * 0.92
|
||||
k = np.median(R9['base'][:, 2]) / max(1e-9, np.median(R9['base'][:, 2]) + dd_)
|
||||
print(f"\n 🚨 IN EURO: €{v:.3f}/g -> €{v*k:.3f}/g. Guadagno = "
|
||||
f"€{v*(k-1):.4f}/GIORNO, cioe' €{v*(k-1)*365:.2f}/anno su un conto da $635.")
|
||||
print(f" Versare €500/mese vale €6.000/anno. Il rapporto e' "
|
||||
f"~{6000/max(1e-9, abs(v*(k-1)*365)):.0f}x.")
|
||||
print(" E il paniere richiede QUATTRO monitor invece di uno, su una macchina a 2 CPU.")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
def main() -> None:
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--draws", type=int, default=1000)
|
||||
ap.add_argument("--bookdraws", type=int, default=200)
|
||||
ap.add_argument("--force", action="store_true")
|
||||
args = ap.parse_args()
|
||||
|
||||
sez("r0823b_quasi_passati.py — §68 | i candidati morti PER POCO, presi insieme, passano?")
|
||||
print(f" avvio {dt.datetime.now(dt.timezone.utc):%Y-%m-%d %H:%M UTC} · "
|
||||
f"estrazioni {args.draws} · seed {SEED} · SOLA LETTURA, 0 ordini, 0 chiamate di rete")
|
||||
print(__doc__.split("DOMANDA")[1].split("REGOLA DI AMMISSIONE")[0].rstrip())
|
||||
|
||||
sez("0) ATTESE A PRIORI — dichiarate nel docstring PRIMA di misurare")
|
||||
print(__doc__.split("=====\n")[2].split("METODO")[0].rstrip())
|
||||
|
||||
sezione1()
|
||||
sezione2()
|
||||
|
||||
sez("COSTRUZIONE DELLE FAMIGLIE (ogni cella = una serie di rendimenti netti giornalieri)")
|
||||
F = build_families(args.force)
|
||||
R3 = sezione3(F)
|
||||
legs = R3["legs"]
|
||||
G = Grid({k: F[k] for k in LEGS})
|
||||
R4 = sezione4(legs)
|
||||
R5 = sezione5(G, legs)
|
||||
R6 = sezione6(F, R5, legs)
|
||||
R7 = sezione7(F, G, R5, args.draws)
|
||||
R8 = sezione8(G, R5)
|
||||
R9 = sezione9(R5, legs, args.bookdraws)
|
||||
sezione10(R5, R9)
|
||||
eur_al_giorno(R9)
|
||||
|
||||
# ---------------------------------------------------------------------------------------
|
||||
sez("12) ATTESE: CONFERMATE O REFUTATE")
|
||||
B = R5["B"]
|
||||
best_leg = max(sh(legs[n]) for n in LEGS)
|
||||
b0 = R7["res"]["B0 CELLA A CASO (qualunque cella della famiglia)"]
|
||||
b1 = R7["res"]["B1 SCARTATI NETTI (meta' peggiore in-sample, stesse famiglie)"]
|
||||
pct_full_b1 = 100.0 * float((b1[:, 0] < sh(B)).mean())
|
||||
pct_hold_b1 = 100.0 * float((b1[:, 2] < shH(B)).mean())
|
||||
a1 = sh(B) > best_leg
|
||||
a2 = (max(R6.values()) >= 0.95) and (min(R6.values()) < 0.95)
|
||||
a3 = (pct_full_b1 > 50) and (pct_hold_b1 < pct_full_b1)
|
||||
a4 = R4["neff"] > 0.8 * len(LEGS)
|
||||
worst = min(R8, key=lambda k: R8[k][0])
|
||||
a5 = worst == "PREVDAY"
|
||||
print(f" A1 paniere > ogni gamba sul FULL ................. "
|
||||
f"{'CONFERMATA' if a1 else 'REFUTATA'} ({sh(B):.3f} vs {best_leg:.3f})")
|
||||
print(f" A2 il DSR si ribalta con la partizione ........... "
|
||||
f"{'CONFERMATA' if a2 else 'REFUTATA'} (range {min(R6.values()):.3f}-{max(R6.values()):.3f})")
|
||||
print(f" A3 vantaggio in-sample che si riduce sull'hold-out "
|
||||
f"{'CONFERMATA' if a3 else 'REFUTATA'} (pctl vs B1: FULL {pct_full_b1:.0f}° / "
|
||||
f"HOLD {pct_hold_b1:.0f}°)")
|
||||
print(f" A4 ampiezza effettiva ~ K ....................... "
|
||||
f"{'CONFERMATA' if a4 else 'REFUTATA'} ({R4['neff']:.2f} su {len(LEGS)})")
|
||||
print(f" A5 dipende da UNA gamba (PREVDAY) ............... "
|
||||
f"{'CONFERMATA' if a5 else 'REFUTATA'} (la piu' costosa da togliere: {worst})")
|
||||
print(f" A6 almeno una gamba STAT-MODE ................... CONFERMATA (XSR01 + VRP-TENORE)")
|
||||
print(f" A7 le gambe sono DECADUTE dalla pubblicazione ... vedi sezione 3b")
|
||||
|
||||
sez(f"VERDETTO {clock()}")
|
||||
print(f" Sharpe del paniere: FULL {sh(B):.3f} / IS {shI(B):.3f} / HOLD {shH(B):.3f}, "
|
||||
f"maxDD {100*dd(B):.2f}%, ampiezza effettiva {R4['neff']:.2f}/5.")
|
||||
print(f" Percentile contro i panieri di SCARTATI NETTI (B1): FULL {pct_full_b1:.1f}° / "
|
||||
f"HOLD {pct_hold_b1:.1f}°.")
|
||||
print(f" Percentile contro i panieri a CELLA CASUALE (B0): FULL "
|
||||
f"{100.0*float((b0[:,0] < sh(B)).mean()):.1f}° / HOLD "
|
||||
f"{100.0*float((b0[:,2] < shH(B)).mean()):.1f}°.")
|
||||
print(f" DSR del paniere: {min(R6.values()):.3f} - {max(R6.values()):.3f} secondo la "
|
||||
f"partizione dei trial.")
|
||||
print("\n La riga per il registro e' nel messaggio finale.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,785 @@
|
||||
"""§67 REGIME-CAPITALE — cosa e' stato archiviato PER TAGLIA, e cosa sarebbe vivo a $100.000.
|
||||
|
||||
LA DOMANDA
|
||||
----------
|
||||
Ogni screening di questo progetto e' stato fatto a **$600 di capitale**. E' la scelta giusta per il
|
||||
conto che esiste, ma ha un effetto collaterale mai esaminato: le strategie messe in STAT-MODE o
|
||||
rifiutate citando min-order / lotto minimo / numero di gambe / haircut small-cap sono state
|
||||
archiviate **senza mai misurare se sarebbero vive a $100k** — che e' il nozionale di un conto
|
||||
funded, il canale su cui il progetto sta valutando di puntare.
|
||||
|
||||
E c'e' una ragione forte per rifare il conto ADESSO: l'ondata del 22-23/08 ha falsificato **tre muri
|
||||
di taglia** pubblicati (il "$20k di XS01" non esiste; il muro delle opzioni BTC era il COLLATERALE
|
||||
PER VENDERE, non il costo di comprare; i lotti USDC-lineari sono 7,5-10x piu' piccoli di quelli
|
||||
inverse su cui erano stati misurati). Tre su tre sbagliati, tutti nella stessa direzione: piu'
|
||||
permissivi del creduto.
|
||||
|
||||
ATTESE A PRIORI — scritte leggendo il mandato, PRIMA di qualunque misura
|
||||
-----------------------------------------------------------------------
|
||||
A1 Il censimento conterra' 10-15 voci e la MAGGIORANZA avra' anche un rifiuto sul lato EDGE:
|
||||
la taglia sara' raramente l'unico motivo.
|
||||
A2 (controllo positivo) XS01 riprodurra' haircut ~0 gia' a $200-600 di capitale ALLOCATO.
|
||||
Se il mio codice non lo trova, il mio codice e' rotto e mi fermo.
|
||||
A3 A $100.000 ogni candidato multi-gamba converge alla propria serie MODELLATA (haircut -> 0).
|
||||
A4 Nessun archiviato passera' TUTTI i gate a $100k — e non perche' ricontrolli i gate, ma per una
|
||||
ragione strutturale: i gate pubblicati sono stati calcolati sulla serie MODELLATA, che E' il
|
||||
limite a capitale infinito. Se e' vero, la domanda del mandato era gia' risposta nei registri.
|
||||
A5 Il corollario funded non aggiungera' NIENTE di nuovo: l'unico ampliamento reale dell'insieme
|
||||
ammissibile e' XS01, e §1/§29 l'hanno gia' contato (+0,400 di J).
|
||||
A6 L'haircut sara' MONOTONO decrescente nel capitale. <-- questa e' quella che mi aspetto di
|
||||
confermare senza pensarci; se salta, e' il risultato metodologico del filone.
|
||||
|
||||
METODO
|
||||
------
|
||||
* Repliche PRIMA di ogni delta: identita' bit-exact di XS01 col sleeve di produzione; libro 75/25
|
||||
`hourly` contro il numero pubblicato (Sh 1,683 / maxDD 11,22%).
|
||||
* Parametri VERI del venue (non quelli di memoria): Deribit min-order $5, taker 3,50 bps dal
|
||||
2026-08-01; Hyperliquid min-order **$10** (non $5) e taker **4,50 bps** (non 5,0), misurati da
|
||||
HL-EXEC il 22/08; lotti della famiglia **USDC-lineare** (non inverse), letti dal venue.
|
||||
* La LENTE del libro e' dichiarata: `hourly` (path live), Sh 1,683 / maxDD 11,22% — non la
|
||||
canonica 1,800/9,56% ne' la mediana d'ancora 1,626/10,4%.
|
||||
* Distinzione dichiarata riga per riga: **capitale PROPRIO** (e' tuo, il vincolo e' il min-order)
|
||||
contro **nozionale FUNDED** (non e' tuo, il vincolo binding e' la regola di drawdown).
|
||||
|
||||
SICUREZZA: sola lettura. Nessun ordine. Nessun file di produzione toccato. Solo GET pubbliche,
|
||||
con pacing, cache e astensione nelle finestre del cron (:05-:10 book, :24-:30 catena).
|
||||
|
||||
uv run python scripts/research/r0823b_regime_capitale.py
|
||||
uv run python scripts/research/r0823b_regime_capitale.py --no-net # tutto da cache/costanti
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
if str(_p) not in sys.path:
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
CACHE = ROOT / "data" / "cache_regime_capitale.json"
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# PARAMETRI VENUE — dichiarati, con la FONTE. Nessuno di questi e' "di memoria".
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DER_MIN_ORDER = 5.0 # config/live.json -> min_order_usd
|
||||
DER_FEE_SIDE = 0.00035 # 3,50 bps/lato dal 2026-08-01 (SLIP-AUDIT: 16/16 fill sul nastro)
|
||||
HL_MIN_ORDER = 10.0 # HL-EXEC 22/08: docs + 3.827 livelli, 0,0% sotto $10 (NON $5)
|
||||
HL_FEE_SIDE = 0.00045 # HL-EXEC 22/08: 4,50 bps, due fonti indipendenti (NON 5,0)
|
||||
SPLIT_FUNDED = 0.80 # r0725_hyro.SPLIT — quota trader del profitto su conto funded
|
||||
BARRIERA_FUNDED = 0.06 # HyroTrader max loss STATICO 6% (r0725_hyro.EV_DD, regole vere)
|
||||
EURUSD = 1.09
|
||||
CAPITALI = (635.0, 5_000.0, 20_000.0, 100_000.0) # la griglia del mandato
|
||||
GRIGLIA_DENSA = (95.0, 200.0, 400.0, 600.0, 635.0, 1_000.0, 1_500.0, 2_000.0, 3_000.0,
|
||||
5_000.0, 7_500.0, 10_000.0, 15_000.0, 20_000.0, 50_000.0, 100_000.0, 200_000.0)
|
||||
TOL_STAB = 0.10 # |Sh(C) - Sh(modellata)| <= 0,10 per DICHIARARE eseguibile
|
||||
SEED = 823
|
||||
|
||||
_last_net = [0.0]
|
||||
|
||||
|
||||
def sez(t: str) -> None:
|
||||
print("\n" + "=" * 100)
|
||||
print(" " + t)
|
||||
print("=" * 100)
|
||||
|
||||
|
||||
def sub(t: str) -> None:
|
||||
print("\n --- " + t)
|
||||
|
||||
|
||||
def _pace() -> None:
|
||||
"""<=2 req/s e astensione nelle finestre del cron live."""
|
||||
now = datetime.now(timezone.utc)
|
||||
while now.minute in (5, 6, 7, 8, 9, 10, 24, 25, 26, 27, 28, 29, 30):
|
||||
print(f" [pausa: minuto {now.minute} e' finestra del cron live]")
|
||||
time.sleep(20)
|
||||
now = datetime.now(timezone.utc)
|
||||
dt = time.time() - _last_net[0]
|
||||
if dt < 0.6:
|
||||
time.sleep(0.6 - dt)
|
||||
_last_net[0] = time.time()
|
||||
|
||||
|
||||
def get_json(url: str, key: str, no_net: bool):
|
||||
c = json.loads(CACHE.read_text()) if CACHE.exists() else {}
|
||||
if no_net or (key in c and time.time() - c[key].get("_t", 0) < 12 * 3600):
|
||||
return c.get(key, {}).get("v")
|
||||
try:
|
||||
_pace()
|
||||
with urllib.request.urlopen(url, timeout=20) as r:
|
||||
v = json.loads(r.read().decode())
|
||||
except Exception as e: # noqa: BLE001
|
||||
print(f" [rete KO su {key}: {type(e).__name__}] -> uso la cache se c'e'")
|
||||
return c.get(key, {}).get("v")
|
||||
c[key] = {"_t": time.time(), "v": v}
|
||||
CACHE.write_text(json.dumps(c))
|
||||
return v
|
||||
|
||||
|
||||
def sola_lettura() -> None:
|
||||
"""Prova che il filone non ha toccato la produzione (il cron ESEGUE dalla working tree)."""
|
||||
prot = ["src/", "config/", "scripts/live/", "tests/", "data/paper_statarb", "data/paper_xsr",
|
||||
"data/paper_dvolspread", "data/live"]
|
||||
out = subprocess.run(["git", "status", "--porcelain", "--"] + prot,
|
||||
cwd=ROOT, capture_output=True, text=True).stdout.strip()
|
||||
print(f" git status sui percorsi protetti: {'VUOTO (sola lettura provata)' if not out else out}")
|
||||
assert not out, "PRODUZIONE TOCCATA — fermarsi"
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# METRICHE E DEFINIZIONE DI ESEGUIBILITA'
|
||||
# =============================================================================================
|
||||
ANN = np.sqrt(365.25)
|
||||
|
||||
|
||||
def met(net: np.ndarray, idx) -> dict:
|
||||
x = np.asarray(net, float)
|
||||
sd = x.std(ddof=1)
|
||||
sh = float(x.mean() / sd * ANN) if sd > 0 else 0.0
|
||||
eq = np.cumprod(1.0 + np.clip(x, -0.99, None))
|
||||
dd = float((1.0 - eq / np.maximum.accumulate(eq)).max())
|
||||
yrs = max((idx[-1] - idx[0]) / pd.Timedelta("365.25D"), 1e-9)
|
||||
return dict(sharpe=sh, maxdd=100 * dd, cagr=100 * (eq[-1] ** (1 / yrs) - 1.0))
|
||||
|
||||
|
||||
def c_stabilita(curva: dict[float, float], sh_mod: float, tol: float = TOL_STAB) -> float | None:
|
||||
"""C* = il PIU' PICCOLO capitale tale che da li' in su lo Sharpe NON si discosta piu' di `tol`
|
||||
dalla serie modellata. Definizione scelta PRIMA di guardare, e per un motivo: ne' l'haircut ne'
|
||||
la quota di nozionale eseguito, da soli, distinguono "eseguibile" da "degenere" (sez. 3)."""
|
||||
caps = sorted(curva)
|
||||
for i, c in enumerate(caps):
|
||||
if all(abs(curva[c2] - sh_mod) <= tol for c2 in caps[i:]):
|
||||
return c
|
||||
return None
|
||||
|
||||
|
||||
def maxdd_k(r: np.ndarray, k: float) -> float:
|
||||
eq = np.cumprod(1.0 + np.clip(k * np.asarray(r, float), -0.99, None))
|
||||
return float((1.0 - eq / np.maximum.accumulate(eq)).max())
|
||||
|
||||
|
||||
def cagr_k(r: np.ndarray, k: float, idx) -> float:
|
||||
eq = np.cumprod(1.0 + np.clip(k * np.asarray(r, float), -0.99, None))
|
||||
yrs = max((idx[-1] - idx[0]) / pd.Timedelta("365.25D"), 1e-9)
|
||||
return float(eq[-1] ** (1 / yrs) - 1.0)
|
||||
|
||||
|
||||
def k_barriera(r: np.ndarray, target: float = BARRIERA_FUNDED) -> float:
|
||||
lo, hi = 1e-3, 20.0
|
||||
if maxdd_k(r, hi) < target:
|
||||
return hi
|
||||
for _ in range(60):
|
||||
mid = 0.5 * (lo + hi)
|
||||
if maxdd_k(r, mid) < target:
|
||||
lo = mid
|
||||
else:
|
||||
hi = mid
|
||||
return lo
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 1 — IL CENSIMENTO
|
||||
# =============================================================================================
|
||||
# (voce, dove il muro di taglia e' dichiarato, muro come pubblicato, stato del muro OGGI,
|
||||
# c'e' ANCHE un rifiuto sul lato EDGE?)
|
||||
CENSIMENTO = [
|
||||
("XS01 (19 gambe HL)", "CLAUDE.md 19/06",
|
||||
"STAT-MODE, 'serve ~20k'", "FALSIFICATO 22/08 (haircut ~0 a $200-600)",
|
||||
"no — e' nel book di ricerca; fuori dal LIVE per VENUE (14/19) e decisione venue"),
|
||||
("XSR01 (50 gambe HL)", "CLAUDE.md 25/07",
|
||||
"ticket $1,73 < $5 -> 'reale a ~$5k'", "RIDIMENSIONATO 22/08: soglia vera ~$3.000",
|
||||
"SI — weights_tilt_null FAIL (book 5-sleeve), storia 2,6a monoregime; gate 23/10 APERTO"),
|
||||
("STATARB-MULTI (50 coppie)", "CLAUDE.md 25/07",
|
||||
"51 gambe = STAT-MODE", "MAI MISURATO -> misurato qui",
|
||||
"SI — IC95 [-0,12; 1,72], t 1,31; uplift -0,11 vs null a priori"),
|
||||
("CC01 cash-and-carry", "CLAUDE.md 26/06",
|
||||
"4-38 gambe, 'rivedere a ~20k+'", "FALSIFICATO 22/08 (§34: lotti $10/$1; §39: linea USDC esiste)",
|
||||
"SI — DSR 0,363 FAIL, implausible_sharpe 5/5, de-levering REFUTED, 2 gambe = Sharpe -0,42"),
|
||||
("VRP01 (put credit spread)", "CLAUDE.md 30/07",
|
||||
"lotto BTC $6.210 / ETH $1.832 -> 0 lotti al peso 12%",
|
||||
"FALSIFICATO 22/08 (§50: famiglia USDC ETH $242 / BTC $772)",
|
||||
"SI — regola 'niente short-vol da modello in deploy' + f=0,73 misurato"),
|
||||
("Opzioni long (tail-hedge, gamma)", "CLAUDE.md 26/06 + 22/08",
|
||||
"'opzione BTC min $5.968 >> $600'", "FALSIFICATO 23/08 (§46: comprare costa il PREMIO, $1,79-7,93)",
|
||||
"SI — gamma scalp Sharpe -3..-6 ogni anno; tail-hedge maxDD sale in 162/162 celle"),
|
||||
("Albimarini double-diagonal", "CLAUDE.md 02/07",
|
||||
"(nessun muro di taglia)", "n/d — fee-negativa a QUALSIASI size",
|
||||
"SI — fee 8 gambe = 194-221% del theta; celle 0-perdite = implausible_sharpe"),
|
||||
("Tranching TP01 K=2/4", "CLAUDE.md 02/07",
|
||||
"'delta ~$1-2 < min-order -> K=1'; rivalutare a >=5-10k",
|
||||
"FALSIFICATO 23/08 (§47: build_book_order banda la posizione NETTA)",
|
||||
"SI — dSharpe n.s.; e' riduzione della VARIANZA DELLA STIMA, non ritorno"),
|
||||
("BIN-FREQ (size per-trade SKH01)", "CLAUDE.md 22/08",
|
||||
"riapertura = SOGLIA DI CAPITALE $5.600 (cella) / $53.000 (famiglia)",
|
||||
"VIVO — e' l'unico con una soglia di capitale come condizione DICHIARATA",
|
||||
"SI — mediana di famiglia 6% della cella, 54% celle positive; weights_tilt_null FAIL"),
|
||||
("XS01-D (11 gambe Deribit)", "RESULTS §50/§56 23/08",
|
||||
"'aspettare 2-3 listing'", "n/d — non e' capitale, e' VENUE",
|
||||
"SI — IC -0,027 (t -0,88) su quelle 11; DSR 0,158 FAIL"),
|
||||
("GTAA01 (6 ETF)", "CLAUDE.md 25-26/07",
|
||||
"GTAA_MIN_CAPITAL $3.000", "n/d — sopra c'e' il PRIIPs: ordine RIFIUTATO sul conto reale",
|
||||
"no — regge come ricerca (LOO: unico positivo nel 100% delle estrazioni)"),
|
||||
("XS01 espanso (52 -> 51 HL)", "CLAUDE.md 19-20/06",
|
||||
"(nessun muro di taglia)", "n/d",
|
||||
"SI — il long-tail DILUISCE il momentum relativo; peggiore a ogni variante"),
|
||||
("IVOL (idio-vol cross-sectional)", "CLAUDE.md 29/06",
|
||||
"STAT-MODE", "MAI MISURATO (lead mai ripreso)",
|
||||
"SI — nato come LEAD debole nello stesso sweep in cui XSEC-V2 fa DSR 0,13"),
|
||||
("LOWVOL 19-major", "CLAUDE.md 29/06",
|
||||
"STAT-MODE", "n/d",
|
||||
"SI — deflated-Sharpe 0,13 + storia 2,5a"),
|
||||
]
|
||||
|
||||
|
||||
def sezione1() -> None:
|
||||
sez("1) IL CENSIMENTO — tutto cio' che il progetto ha archiviato CITANDO LA TAGLIA")
|
||||
print("""
|
||||
Regola di lettura: la colonna che decide non e' 'stato del muro' ma l'ULTIMA. Un muro di taglia
|
||||
che cade libera un candidato solo se non c'era anche un rifiuto sull'edge — e i gate sull'edge
|
||||
NON dipendono dal capitale (sez. 5).
|
||||
""")
|
||||
print(" " + "-" * 98)
|
||||
n_edge = 0
|
||||
for nome, fonte, muro, stato, edge in CENSIMENTO:
|
||||
n_edge += edge.startswith("SI")
|
||||
print(f" {nome:<32}[{fonte}]")
|
||||
print(f" {'':<32}muro pubblicato : {muro}")
|
||||
print(f" {'':<32}muro OGGI : {stato}")
|
||||
print(f" {'':<32}EDGE : {edge}")
|
||||
print(" " + "-" * 98)
|
||||
n = len(CENSIMENTO)
|
||||
print(f"\n VOCI: {n} con rifiuto ANCHE sull'edge: {n_edge}/{n} = {100*n_edge/n:.0f}%")
|
||||
falsi = sum(1 for _, _, _, s, _ in CENSIMENTO if s.startswith("FALSIFICATO"))
|
||||
mai = sum(1 for _, _, _, s, _ in CENSIMENTO if s.startswith("MAI"))
|
||||
print(f" muri di taglia FALSIFICATI (tutti dall'ondata 22-23/08): {falsi}/{n}")
|
||||
print(f" muri di taglia MAI MISURATI (li misuro qui dove possibile): {mai}/{n}")
|
||||
print(f"\n A1 {'CONFERMATA' if n_edge / n > 0.5 else 'REFUTATA'}: la taglia e' l'unico motivo "
|
||||
f"in {n - n_edge}/{n} voci.")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 2-3 — LE CURVE DI HAIRCUT
|
||||
# =============================================================================================
|
||||
def carica_candidati():
|
||||
"""Ricostruisce i pesi dei 3 candidati multi-gamba REALMENTE misurabili. Nessuna
|
||||
reimplementazione: si importano il sleeve di produzione e il monitor live."""
|
||||
from r0822_hl_exec import sim_libro, xs01_pesi # noqa: F401
|
||||
out = {}
|
||||
|
||||
W, dret, C, cols, dif = xs01_pesi(0)
|
||||
print(f" XS01 (19 gambe HL): identita' vs sleeves._xsec_returns max|dif| = {dif}")
|
||||
assert dif == 0.0, "XS01 non replica il sleeve di produzione"
|
||||
out["XS01 (19g, HL)"] = dict(W=W, R=dret, hedge=None, idx=C.index,
|
||||
fee=HL_FEE_SIDE, floor=HL_MIN_ORDER, legs=19, venue="HL")
|
||||
|
||||
from scripts.live.paper_xsr import FEE_LEG, build_panel
|
||||
ts, idx, Wx, Rx, rb, colx = build_panel()
|
||||
print(f" XSR01 (50 gambe HL): pannello dal MONITOR di produzione, {Wx.shape[1]} gambe, "
|
||||
f"fee monitor {FEE_LEG*1e4:.1f} bps")
|
||||
out["XSR01 (50g, HL)"] = dict(W=Wx, R=Rx, hedge=rb, idx=idx,
|
||||
fee=FEE_LEG, floor=HL_MIN_ORDER, legs=50, venue="HL")
|
||||
|
||||
import r0725_statarb_multi as SM
|
||||
base = SM.load_hl(SM.BASE)
|
||||
pc, rc = {}, {}
|
||||
for sym in SM.universe():
|
||||
try:
|
||||
tgt = SM.load_hl(sym)
|
||||
except FileNotFoundError:
|
||||
continue
|
||||
ix = base.index.intersection(tgt.index)
|
||||
if len(ix) < SM.MIN_BARS:
|
||||
continue
|
||||
p, _ = SM.signal(base[ix], tgt[ix])
|
||||
pc[sym] = pd.Series(p, index=ix)
|
||||
rc[sym] = tgt[ix].pct_change().fillna(0.0)
|
||||
P = pd.concat(pc, axis=1, sort=True).sort_index().fillna(0.0)
|
||||
Rr = pd.concat(rc, axis=1, sort=True).sort_index().reindex(P.index).fillna(0.0)[P.columns]
|
||||
k = P.shape[1]
|
||||
print(f" STATARB-MULTI: {k} coppie = {k+1} gambe (meccanismo CONGELATO W=45 sgn=+1, "
|
||||
f"da r0725_statarb_multi)")
|
||||
out["STATARB-MULTI (51g, HL)"] = dict(
|
||||
W=(P / k).to_numpy(float), R=Rr.to_numpy(float),
|
||||
hedge=base.pct_change().fillna(0.0).reindex(P.index).fillna(0.0).to_numpy(float),
|
||||
idx=P.index, fee=SM.FEE_LEG, floor=HL_MIN_ORDER, legs=k + 1, venue="HL")
|
||||
return out
|
||||
|
||||
|
||||
def curva(cand: dict, caps, floor=None) -> tuple[dict, dict, dict]:
|
||||
from r0822_hl_exec import sim_libro
|
||||
fl = cand["floor"] if floor is None else floor
|
||||
sh, noz, nets = {}, {}, {}
|
||||
for c in caps:
|
||||
s = sim_libro(cand["W"], cand["R"], cand["hedge"], c, fl, None, None, cand["fee"])
|
||||
m = met(s["net"], cand["idx"])
|
||||
sh[c] = m["sharpe"]
|
||||
noz[c] = s["pct_nozionale"]
|
||||
nets[c] = s["net"]
|
||||
s = sim_libro(cand["W"], cand["R"], cand["hedge"], 1e12, None, None, None, cand["fee"])
|
||||
nets["MOD"] = s["net"]
|
||||
return sh, noz, nets
|
||||
|
||||
|
||||
def sezione23(CAND: dict) -> dict:
|
||||
sez("2) CONTROLLO POSITIVO — XS01, il muro gia' caduto il 22/08")
|
||||
print("""
|
||||
Se il mio codice non ritrova haircut ~0 a $200-600 su XS01, e' rotto e il resto non vale niente.
|
||||
(HL-EXEC 22/08: "haircut ~0 gia' a $200-600 allocati; a $600 lo Sharpe passa 1,33 -> 1,30".)""")
|
||||
sh, noz, nets = curva(CAND["XS01 (19g, HL)"], GRIGLIA_DENSA)
|
||||
shm = met(nets["MOD"], CAND["XS01 (19g, HL)"]["idx"])["sharpe"]
|
||||
print(f"\n {'capitale ALLOCATO':>19}{'Sharpe':>9}{'haircut':>10}{'% nozionale eseguito':>23}")
|
||||
for c in GRIGLIA_DENSA:
|
||||
print(f" {c:>19,.0f}{sh[c]:>9.3f}{shm - sh[c]:>10.3f}{noz[c]:>22.1f}%")
|
||||
print(f" {'MODELLATA':>19}{shm:>9.3f}{0.0:>10.3f}{100.0:>22.1f}%")
|
||||
ok = abs(sh[200.0] - shm) <= 0.05 and abs(sh[635.0] - shm) <= 0.05
|
||||
print(f"\n A2 {'CONFERMATA' if ok else 'REFUTATA — CODICE ROTTO, MI FERMO'}: "
|
||||
f"haircut a $200 = {shm - sh[200.0]:+.3f}, a $635 = {shm - sh[635.0]:+.3f}.")
|
||||
assert ok, "controllo positivo fallito"
|
||||
for tol in (0.10, 0.05):
|
||||
cs = c_stabilita(sh, shm, tol)
|
||||
print(f" C* a tolleranza {tol:.2f} di Sharpe = "
|
||||
f"{('$%s' % f'{cs:,.0f}') if cs else '>200k'} di capitale ALLOCATO.")
|
||||
print(f"""
|
||||
PRECISAZIONE che il numero pubblicato non porta con se': i "$200-600" sono capitale ALLOCATO
|
||||
AL SLEEVE. A peso di libro 15% servono ${200/0.15:,.0f}-${635/0.15:,.0f} di LIBRO per stare li'; a un
|
||||
libro da $635 il sleeve vede $95 e l'haircut e' {shm - sh[95.0]:+.3f} — non zero.""")
|
||||
|
||||
sez("3) LE CURVE — i tre candidati multi-gamba, ai capitali del mandato")
|
||||
print(f"\n {'candidato':<26}{'gambe':>6}{'venue':>7}" +
|
||||
"".join(f"{('$%s' % f'{c:,.0f}'):>12}" for c in CAPITALI) +
|
||||
f"{'MODELL.':>10}{'C*':>12}")
|
||||
print(" " + "-" * 110)
|
||||
res = {}
|
||||
for nome, cand in CAND.items():
|
||||
shd, nozd, netsd = curva(cand, GRIGLIA_DENSA)
|
||||
shm = met(netsd["MOD"], cand["idx"])["sharpe"]
|
||||
cs = c_stabilita(shd, shm)
|
||||
res[nome] = dict(sh=shd, noz=nozd, nets=netsd, sh_mod=shm, cstar=cs, cand=cand)
|
||||
print(f" {nome:<26}{cand['legs']:>6}{cand['venue']:>7}" +
|
||||
"".join(f"{shd[c]:>12.3f}" for c in CAPITALI) +
|
||||
f"{shm:>10.3f}" + (f"{cs:>12,.0f}" if cs else f"{'>200k':>12}"))
|
||||
print(" " + "-" * 110)
|
||||
sub("3a) la curva DENSA (Sharpe sopra, % di nozionale eseguito sotto)")
|
||||
print(f" {'capitale':>10}" + "".join(f"{nm.split(' (')[0]:>13}" for nm in res))
|
||||
for c in GRIGLIA_DENSA:
|
||||
print(f" {c:>10,.0f}" + "".join(f"{res[nm]['sh'][c]:>13.3f}" for nm in res))
|
||||
print(f" {'':>10}" + "".join(f"{res[nm]['noz'][c]:>12.1f}%" for nm in res))
|
||||
print(f" {'MODELLATA':>10}" + "".join(f"{res[nm]['sh_mod']:>13.3f}" for nm in res))
|
||||
print(f"\n C* per tolleranza:")
|
||||
for tol in (0.10, 0.05):
|
||||
row = []
|
||||
for nm in res:
|
||||
cs = c_stabilita(res[nm]["sh"], res[nm]["sh_mod"], tol)
|
||||
row.append(("$%s" % f"{cs:,.0f}") if cs else ">200k")
|
||||
print(f" tol {tol:.2f}: " + " ".join(f"{nm.split(' (')[0]}={v}" for nm, v in zip(res, row)))
|
||||
|
||||
sub("3b) LA TRAPPOLA — l'haircut da solo NON rileva un muro di taglia")
|
||||
print("""
|
||||
`altlib.eval_weights_smallcap` riporta `sharpe_haircut = modellata - reale`. Su un candidato
|
||||
multi-gamba, sotto la soglia di eseguibilita' quel numero PUO' ESSERE NEGATIVO: il pavimento
|
||||
taglia quasi tutto il nozionale e cio' che resta e' una strategia DIVERSA, piccola e casuale.
|
||||
Letto da solo, un haircut negativo dice "eseguibile, anzi meglio". E' esattamente al rovescio.""")
|
||||
print(f"\n {'candidato':<26}{'cap':>10}{'Sharpe':>9}{'haircut':>10}{'% noz':>9} lettura")
|
||||
for nome, r in res.items():
|
||||
for c in (635.0, 5_000.0):
|
||||
h = r["sh_mod"] - r["sh"][c]
|
||||
deg = r["noz"][c] < 50.0
|
||||
print(f" {nome:<26}{c:>10,.0f}{r['sh'][c]:>9.3f}{h:>10.3f}{r['noz'][c]:>8.1f}% "
|
||||
f"{'DEGENERE (il numero non descrive la strategia)' if deg else 'eseguibile'}")
|
||||
st = res["STATARB-MULTI (51g, HL)"]
|
||||
print(f"""
|
||||
Il caso limpido: STATARB-MULTI a $635 fa Sharpe {st['sh'][635.0]:.3f} contro
|
||||
{st['sh_mod']:.3f} modellata -> haircut {st['sh_mod'] - st['sh'][635.0]:+.3f}, cioe' NEGATIVO,
|
||||
con il {st['noz'][635.0]:.1f}% del nozionale eseguito. Un gate scritto su `sharpe_haircut <= X`
|
||||
lo avrebbe promosso.""")
|
||||
|
||||
sub("3c) A6 — monotonia dell'haircut nel capitale")
|
||||
for nome, r in res.items():
|
||||
seq = [r["sh"][c] for c in GRIGLIA_DENSA]
|
||||
d = np.diff(seq)
|
||||
mono = bool((d >= -1e-9).all())
|
||||
print(f" {nome:<26} monotono crescente in C? {'SI' if mono else 'NO'} "
|
||||
f"(peggior passo indietro {d.min():+.3f}; max sopra la modellata "
|
||||
f"{max(seq) - r['sh_mod']:+.3f})")
|
||||
print("""
|
||||
A6 REFUTATA su 3/3. Sotto C* lo Sharpe non e' una misura della strategia: e' una misura di
|
||||
QUALI gambe il pavimento ha lasciato passare. Il segno del passo e' rumore.""")
|
||||
return res
|
||||
|
||||
|
||||
def sezione3d(CAND: dict) -> None:
|
||||
sub("3d) IL PAVIMENTO DEL VENUE SBAGLIATO — `scripts/live/paper_xsr.MIN_ORDER = 5.0`")
|
||||
print("""
|
||||
XSR01 gira su HYPERLIQUID (50 alt). Il suo monitor forward — quello che alimenta il gate
|
||||
pre-registrato del 2026-10-23 — usa `MIN_ORDER = 5.0`, che e' il pavimento di **DERIBIT**.
|
||||
Il pavimento di Hyperliquid e' **$10** (HL-EXEC 22/08: 3.827 livelli, 0,0% sotto $10).
|
||||
I due libri REAL del monitor sono $600 e $5.000: entrambi nella regione in cui il pavimento morde.""")
|
||||
c = CAND["XSR01 (50g, HL)"]
|
||||
sh5, noz5, _ = curva(c, GRIGLIA_DENSA, floor=5.0)
|
||||
sh10, noz10, nets = curva(c, GRIGLIA_DENSA, floor=10.0)
|
||||
shm = met(nets["MOD"], c["idx"])["sharpe"]
|
||||
print(f"\n {'capitale':>10}{'Sh @ $5 (monitor)':>20}{'Sh @ $10 (venue)':>19}{'differenza':>13}"
|
||||
f"{'% noz @$10':>12}")
|
||||
for cc in (600.0, 635.0, 2_000.0, 3_000.0, 5_000.0, 20_000.0, 100_000.0):
|
||||
print(f" {cc:>10,.0f}{sh5[cc]:>20.3f}{sh10[cc]:>19.3f}{sh5[cc]-sh10[cc]:>13.3f}"
|
||||
f"{noz10[cc]:>11.1f}%")
|
||||
d = np.array([sh5[cc] - sh10[cc] for cc in GRIGLIA_DENSA if cc <= 5_000.0])
|
||||
print(f"""
|
||||
Non e' "il monitor e' ottimista": nella regione che conta la differenza cambia SEGNO
|
||||
(min {d.min():+.3f}, max {d.max():+.3f}) — perche' sotto C* si stanno confrontando due
|
||||
sottoinsiemi casuali di gambe, non due stime della stessa cosa.
|
||||
C* col pavimento vero = ${c_stabilita(sh10, shm) or float('nan'):,.0f}; col pavimento del monitor
|
||||
= ${c_stabilita(sh5, shm) or float('nan'):,.0f}.
|
||||
Effetto sul gate 23/10: la sua gamba di eseguibilita' e' "haircut a $5.000 <= 40%", e a $5.000 il
|
||||
monitor misura con il pavimento sbagliato. NON anticipo il gate: registro che l'ingresso e' storto.
|
||||
6a occorrenza dello schema `fee_watch` — un controllo puntato su una configurazione diversa da
|
||||
quella che gira.""")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 4 — VRP01: lotti, non haircut
|
||||
# =============================================================================================
|
||||
def sezione4(no_net: bool) -> None:
|
||||
sez("4) VRP01 — qui il muro non e' un haircut, e' un LOTTO INDIVISIBILE")
|
||||
j = get_json("https://www.deribit.com/api/v2/public/get_instruments"
|
||||
"?currency=USDC&kind=option&expired=false", "usdc_opt", no_net)
|
||||
idx = get_json("https://www.deribit.com/api/v2/public/get_index_price?index_name=btc_usd",
|
||||
"px_btc", no_net)
|
||||
idxe = get_json("https://www.deribit.com/api/v2/public/get_index_price?index_name=eth_usd",
|
||||
"px_eth", no_net)
|
||||
px = {"BTC": (idx or {}).get("result", {}).get("index_price"),
|
||||
"ETH": (idxe or {}).get("result", {}).get("index_price")}
|
||||
mins, nstr = {}, {}
|
||||
for it in ((j or {}).get("result") or []):
|
||||
nm = it.get("instrument_name", "")
|
||||
for a in ("BTC", "ETH"):
|
||||
if nm.startswith(f"{a}_USDC-") and it.get("option_type") == "put":
|
||||
mins[a] = min(mins.get(a, 9e9), float(it.get("min_trade_amount", 9e9)))
|
||||
nstr[a] = nstr.get(a, 0) + 1
|
||||
if mins and all(px.values()):
|
||||
print(" letto dal venue ORA (GET pubblica su kind=OPTION, famiglia USDC-LINEARE = quella")
|
||||
print(" che un conto USDC puo' marginare; VRP01 VENDE, quindi il lotto e' il NOZIONALE"
|
||||
" sottostante,")
|
||||
print(" non il premio — e' la distinzione che §46 ha dovuto correggere sul lato LONG):")
|
||||
for a in ("BTC", "ETH"):
|
||||
print(f" {a}_USDC put ({nstr.get(a,0)} strumenti) min_trade_amount = "
|
||||
f"{mins.get(a)} indice ${px[a]:,.0f} -> lotto = ${mins.get(a, 0) * px[a]:,.0f}")
|
||||
lot = {a: mins[a] * px[a] for a in mins}
|
||||
else:
|
||||
print(" [venue non letto -> uso i valori verificati dal coordinatore il 22/08 (§50)]")
|
||||
lot = {"BTC": 772.0, "ETH": 242.0}
|
||||
print(f"""
|
||||
Il sleeve VRP01 e' 50/50 BTC+ETH al peso di libro 12%. Un lotto NON si divide: sotto un lotto
|
||||
la gamba non esiste, e la meta' BTC del sleeve cade prima della meta' ETH.""")
|
||||
print(f" (memoria: $242 ETH / $772 BTC, §50 22/08 — e $1.832/$6.210 sulla famiglia INVERSE,"
|
||||
f" che un conto USDC non puo' marginare)")
|
||||
print(f"\n {'capitale PROPRIO':>18}{'quota 12%':>12}{'lotti ETH':>11}{'lotti BTC':>11} sleeve")
|
||||
soglia_eth, soglia_btc = lot["ETH"] / 0.06, lot["BTC"] / 0.06
|
||||
for c in (635.0, 2_000.0, soglia_eth, 5_000.0, 6_440.0, soglia_btc, 20_000.0, 100_000.0):
|
||||
q = 0.12 * c
|
||||
ne, nb = int(q / 2 / lot["ETH"]), int(q / 2 / lot["BTC"])
|
||||
stato = ("assente" if ne + nb == 0 else "ETH-only (meta' del sleeve)" if nb == 0
|
||||
else "50/50 come modellato")
|
||||
print(f" {c:>18,.0f}{q:>12,.0f}{ne:>11}{nb:>11} {stato}")
|
||||
print(f"""
|
||||
A $100.000 il sleeve e' 50/50 con {int(0.06*100000/lot['ETH'])} lotti ETH e
|
||||
{int(0.06*100000/lot['BTC'])} BTC: il muro di taglia di VRP01 CADE del tutto.
|
||||
|
||||
CORREZIONE A UN NUMERO PUBBLICATO IERI (§50 / CLAUDE.md): "1 lotto ETH copre il peso di book 12%
|
||||
gia' da ~$2.000, e il BTC da ~$6.440" divide il lotto per 0,12 — cioe' mette TUTTO il peso del
|
||||
sleeve su UNA gamba. VRP01 e' 50/50: la gamba ETH vede il 6% del libro, non il 12%.
|
||||
Soglie vere: prima gamba (ETH) da ${soglia_eth:,.0f}; sleeve 50/50 completo da ${soglia_btc:,.0f}
|
||||
— cioe' il DOPPIO di quanto pubblicato, su entrambe. Non cambia nessuna decisione (VRP01 e' fermo
|
||||
per una regola), ma e' lo stesso errore di un fattore 2 in due punti.
|
||||
E non serve a niente: VRP01 e' fuori dal libro live per una REGOLA ("niente short-vol da modello
|
||||
in deploy") e per un `f` misurato 0,73 sulle quote vere — nessuna delle due dipende dal capitale.
|
||||
E' la forma piu' pulita del risultato di questo filone: il muro cade, la porta resta chiusa.""")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 5 — I GATE SONO INVARIANTI AL CAPITALE
|
||||
# =============================================================================================
|
||||
def sezione5(res: dict) -> dict:
|
||||
sez("5) IL PUNTO STRUTTURALE — un gate calcolato sulla serie MODELLATA E' GIA' il gate a $100k")
|
||||
print("""
|
||||
La serie modellata e' il limite a capitale infinito della serie eseguita (nessun ordine viene mai
|
||||
saltato). Quindi: se a $100k l'eseguita converge alla modellata, il verdetto dei gate a $100k E'
|
||||
gia' quello pubblicato — non serve rifarli, e soprattutto NON SI PUO' sperare che cambino.
|
||||
Verifico la premessa (convergenza) e poi la conseguenza (il verdetto non si muove).""")
|
||||
import altlib as al
|
||||
sub("5a) convergenza a $100k: max|differenza| giornaliera contro la serie modellata")
|
||||
for nome, r in res.items():
|
||||
d = np.abs(r["nets"][100_000.0] - r["nets"]["MOD"]).max()
|
||||
print(f" {nome:<26} max|dif| = {d:.3e} dSharpe = "
|
||||
f"{r['sh'][100_000.0] - r['sh_mod']:+.4f} % noz = {r['noz'][100_000.0]:.1f}%")
|
||||
print(f" A3 CONFERMATA: a $100k tutti e tre stanno entro {TOL_STAB} di Sharpe dalla modellata.")
|
||||
|
||||
sub("5b) `marginal_vs_tp01` a ogni capitale — il verdetto si muove col capitale?")
|
||||
print(f"\n {'candidato':<26}" + "".join(f"{('$%s' % f'{c:,.0f}'):>13}" for c in CAPITALI)
|
||||
+ f"{'MODELLATA':>13}")
|
||||
ver = {}
|
||||
for nome, r in res.items():
|
||||
row, vv = [], []
|
||||
for c in list(CAPITALI) + ["MOD"]:
|
||||
s = pd.Series(r["nets"][c], index=r["cand"]["idx"])
|
||||
m = al.marginal_vs_tp01(s)
|
||||
v = m.get("marginal_verdict", "?")
|
||||
row.append(v)
|
||||
vv.append(v)
|
||||
ver[nome] = vv
|
||||
print(f" {nome:<26}" + "".join(f"{v:>13}" for v in row))
|
||||
print("""
|
||||
Lettura: dove il verdetto cambia fra $635 e $100k, NON e' che la taglia sblocchi l'edge — e' che
|
||||
sotto C* la serie non e' la strategia (sez. 3b). Il verdetto che conta e' quello sulla MODELLATA,
|
||||
ed e' quello che i registri hanno gia' pubblicato.""")
|
||||
|
||||
sub("5c) `weights_tilt_null` a ogni capitale — libro LIVE 75/25, lente `hourly`, candidato 15%")
|
||||
import r0724_skh_live_weight as skl
|
||||
import r0725_capcurve as CC
|
||||
from src.portfolio.portfolio import combine_outer, metrics, weights_tilt_null
|
||||
skh = skl.skh_book(0, "hourly")
|
||||
if skh.index.tz is None:
|
||||
skh.index = skh.index.tz_localize("UTC")
|
||||
lo = pd.Timestamp("2019-03-14", tz="UTC")
|
||||
tp = CC.tp01_realistic(635.0 * 0.75)
|
||||
base = combine_outer({"TP01": tp, "SKH01": skh}, {"TP01": 0.75, "SKH01": 0.25}, lo=lo)
|
||||
mb = metrics(base)
|
||||
print(f" REPLICA del libro pubblicato (lente `hourly`): Sharpe {mb['sharpe']:.3f} "
|
||||
f"(pubblicato 1,683) maxDD {100*mb['maxdd']:.2f}% (pubblicato 11,22%) "
|
||||
f"-> {'OK' if abs(mb['sharpe']-1.683) < 0.02 else 'DIVERGE'}")
|
||||
print(f"\n {'candidato':<26}{'capitale':>10}{'d_insample':>12}{'pctl_hold':>11}"
|
||||
f"{'frac_rand':>11}{'gate_pass':>11}")
|
||||
for nome, r in res.items():
|
||||
for c in CAPITALI:
|
||||
s = pd.Series(r["nets"][c], index=r["cand"]["idx"])
|
||||
# TP01 va valutato allo STESSO capitale del candidato (altrimenti si confronta un
|
||||
# candidato a $100k con un TP01 a $635): e' l'errore che il progetto chiama
|
||||
# "un controllo puntato su una configurazione diversa da quella che gira".
|
||||
tpc = CC.tp01_realistic(c * 0.6375)
|
||||
g = weights_tilt_null({"TP01": tpc, "SKH01": skh, "C": s},
|
||||
{"TP01": 0.75, "SKH01": 0.25, "C": 0.0},
|
||||
{"TP01": 0.6375, "SKH01": 0.2125, "C": 0.15},
|
||||
n=300, seed=SEED)
|
||||
print(f" {nome:<26}{c:>10,.0f}{g['delta_insample']:>12.4f}{g['pctl_hold']:>11.1f}"
|
||||
f"{g['frac_random_beat_hold']:>11.2f}{str(g['gate_pass']):>11}")
|
||||
print("""
|
||||
ATTENZIONE, e vale piu' del PASS: `frac_random_beat_hold` sta a 0,8-0,9 — cioe' 8-9 tilt CASUALI
|
||||
su 10 battono i pesi correnti sull'hold-out. Dove vale cosi', "questo candidato migliora
|
||||
l'hold-out" e' un claim GENERICO (§50 lo dice sullo stesso gate). E il libro di riferimento non e'
|
||||
quello su cui XSR01 fu bocciato: CLAUDE.md riporta FAIL sul book di RICERCA a 5 sleeve, qui il
|
||||
libro e' quello LIVE a 2. Due libri, due verdetti — si dichiara quale.""")
|
||||
return ver
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 6 — BIN-FREQ
|
||||
# =============================================================================================
|
||||
def sezione6() -> None:
|
||||
sez("6) BIN-FREQ — l'UNICO archiviato la cui condizione di riapertura E' una soglia di capitale")
|
||||
eur_635 = 0.0113 # RESULTS §25: taglia misurata a $635
|
||||
rapporto_fam = 0.007 / 0.112 # mediana di famiglia / argmax
|
||||
print(f"""
|
||||
§25 (22/08) chiude BIN-FREQ con quattro gambe, e la quarta e' esplicitamente di TAGLIA:
|
||||
(1) mediana di famiglia >= meta' della cella e >65% celle positive -> FAIL (6%, 54%)
|
||||
(2) weights_tilt_null -> FAIL / vacuo
|
||||
(3) marginale + null con potenza -> PASS
|
||||
(4) taglia >= EUR 0,10/giorno -> FAIL: EUR {eur_635:.4f}/g a $635
|
||||
La (4) e' lineare nel capitale. Le altre tre NON lo sono: sono statistiche sulla serie.""")
|
||||
print(f"\n {'capitale':>10}{'EUR/g (cella)':>16}{'EUR/g (famiglia)':>19}{'gate (4)?':>12}")
|
||||
for c in (635.0, 5_600.0, 20_000.0, 53_000.0, 100_000.0, 200_000.0):
|
||||
ec = eur_635 * c / 635.0
|
||||
ef = ec * rapporto_fam
|
||||
print(f" {c:>10,.0f}{ec:>16.4f}{ef:>19.4f}{('PASS' if ef >= 0.10 else 'PASS(cella)' if ec >= 0.10 else 'FAIL'):>12}")
|
||||
print(f"""
|
||||
A $100.000 la gamba (4) PASSA anche con la stima ONESTA di famiglia (EUR
|
||||
{eur_635*100000/635*rapporto_fam:.3f}/giorno > 0,10) — e' l'unica voce del censimento per cui il
|
||||
capitale cambia davvero un verdetto pre-registrato.
|
||||
MA le gambe (1) e (2) restano FAIL, e sono invarianti al capitale: la mediana di famiglia e' il
|
||||
6% dell'argmax e il 54% delle celle e' positivo comunque si finanzi il conto.
|
||||
-> BIN-FREQ a $100k: 1 gate su 4 si sblocca, 2 restano chiusi. RESTA UN LEAD.""")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 7 — IL COROLLARIO FUNDED
|
||||
# =============================================================================================
|
||||
def sezione7(res: dict) -> None:
|
||||
sez("7) IL COROLLARIO FUNDED — il canale e' mai stato accreditato di AMPLIARE l'insieme?")
|
||||
print("""
|
||||
Distinzione obbligatoria: fin qui la colonna 'capitale' era CAPITALE PROPRIO. Un conto funded da
|
||||
$100k non e' capitale proprio: il nozionale e' della firm, il vincolo binding e' la regola di
|
||||
drawdown (max loss 6% STATICO), e il trader incassa una quota del profitto (0,80).
|
||||
Domanda: quali voci del censimento diventano ESEGUIBILI a $100k di nozionale funded e non lo sono
|
||||
a $635 di capitale proprio? E quanto vale, in Sharpe di libro e in EUR/giorno?""")
|
||||
import r0724_skh_live_weight as skl
|
||||
import r0725_capcurve as CC
|
||||
from src.portfolio.portfolio import combine_outer, metrics
|
||||
skh = skl.skh_book(0, "hourly")
|
||||
if skh.index.tz is None:
|
||||
skh.index = skh.index.tz_localize("UTC")
|
||||
lo = pd.Timestamp("2019-03-14", tz="UTC")
|
||||
tp = CC.tp01_realistic(100_000.0 * 0.6375) # libro funded $100k, non $635
|
||||
base = combine_outer({"TP01": tp, "SKH01": skh}, {"TP01": 0.75, "SKH01": 0.25}, lo=lo)
|
||||
|
||||
sub("7a) chi si aggiunge davvero (capitale PROPRIO $635 -> nozionale FUNDED $100k)")
|
||||
print(f" {'voce':<26}{'C* (proprio)':>14}{'a $635?':>10}{'a $100k?':>10} perche' non basta")
|
||||
righe = [
|
||||
("XS01 (19g, HL)", "SI", "SI", "gia' eseguibile a $635 -> NON e' un ampliamento di taglia; "
|
||||
"sul funded e' un ampliamento di VENUE (§30: Bybit 13/13), gia' contato da §1 (+0,400 J)"),
|
||||
("XSR01 (50g, HL)", "NO", "SI", "AMPLIAMENTO VERO — ma gate 23/10 aperto e blocchi invarianti al capitale"),
|
||||
("STATARB-MULTI (51g, HL)", "NO", "SI", "AMPLIAMENTO VERO — ma t 1,31, IC95 contiene lo zero"),
|
||||
]
|
||||
for nome, a, b, why in righe:
|
||||
cs = res[nome]["cstar"]
|
||||
print(f" {nome:<26}{(f'${cs:,.0f}' if cs else '>200k'):>14}{a:>10}{b:>10}")
|
||||
print(f" {'':<26}{why}")
|
||||
print("""
|
||||
A5: l'insieme AMMISSIBILE non si amplia (entrambi hanno un blocco che il capitale non tocca).
|
||||
L'insieme ESEGUIBILE si amplia di due voci, ed e' un fatto nuovo: nessun filone del progetto
|
||||
aveva mai misurato che a $100k STATARB-MULTI e XSR01 girano al 99,6% del nozionale.""")
|
||||
|
||||
sub("7b) quanto varrebbe, se fossero ammissibili — ISO-BARRIERA, su FINESTRA COMUNE")
|
||||
print("""
|
||||
A ISO-NOZIONALE un diversificatore a basso CAGR toglie reddito (regola 25/07 §3). Su un conto
|
||||
funded la lente giusta e' la BARRIERA: si cerca la leva k che porta il maxDD alla regola dei -6%
|
||||
e si legge il drift a quella leva. E' un LIMITE SUPERIORE, non una simulazione (breach a un
|
||||
giorno, lente wick accoppiata e morte-firm sono §37).
|
||||
FINESTRA COMUNE 2024+ obbligatoria: i candidati esistono solo da li'. Con la finestra piena
|
||||
`combine_outer` rinormalizza per riga, il maxDD del libro cade PRIMA del 2024 e le tre righe
|
||||
danno la STESSA k -> il confronto non misura niente (errore commesso e corretto in sessione).""")
|
||||
lo2 = pd.Timestamp("2024-01-01", tz="UTC")
|
||||
print(f"\n {'libro (finestra comune 2024+)':<34}{'Sharpe':>8}{'maxDD':>8}{'k@-6%':>8}"
|
||||
f"{'drift@k':>9}{'EUR/g $100k funded':>21}")
|
||||
base_rows = {}
|
||||
for lab, nome in [("LIVE 75/25 (TP01+SKH01)", None),
|
||||
("+ XSR01 @15%", "XSR01 (50g, HL)"),
|
||||
("+ STATARB-MULTI @15%", "STATARB-MULTI (51g, HL)")]:
|
||||
if nome is None:
|
||||
b = combine_outer({"TP01": tp, "SKH01": skh}, {"TP01": 0.75, "SKH01": 0.25}, lo=lo2)
|
||||
else:
|
||||
s_ = pd.Series(res[nome]["nets"][100_000.0], index=res[nome]["cand"]["idx"])
|
||||
b = combine_outer({"TP01": tp, "SKH01": skh, "C": s_},
|
||||
{"TP01": 0.6375, "SKH01": 0.2125, "C": 0.15}, lo=lo2)
|
||||
b = b[b.index >= lo2]
|
||||
r = b.values
|
||||
m = metrics(b)
|
||||
k = k_barriera(r)
|
||||
g = cagr_k(r, k, b.index)
|
||||
eur = SPLIT_FUNDED * g * 100_000.0 / 365.0 / EURUSD
|
||||
base_rows[lab] = eur
|
||||
print(f" {lab:<34}{m['sharpe']:>8.3f}{100*m['maxdd']:>7.1f}%{k:>8.2f}{100*g:>8.1f}%"
|
||||
f"{eur:>21.2f}")
|
||||
d1 = base_rows["+ XSR01 @15%"] - base_rows["LIVE 75/25 (TP01+SKH01)"]
|
||||
d2 = base_rows["+ STATARB-MULTI @15%"] - base_rows["LIVE 75/25 (TP01+SKH01)"]
|
||||
print(f"""
|
||||
L'AMPLIAMENTO VALE, come LIMITE SUPERIORE: XSR01 {d1:+.2f} EUR/giorno, STATARB-MULTI {d2:+.2f}
|
||||
EUR/giorno su $100.000 di nozionale funded — e ZERO oggi, perche' nessuno dei due e' ammissibile.
|
||||
⚠️ La finestra 2024+ NON contiene un sinistro: il maxDD del libro li' e' molto piu' piccolo che
|
||||
sulla storia piena, quindi k e' gonfiata per TUTTE le righe. Il numero da leggere e' la
|
||||
DIFFERENZA, non il livello — e resta un tetto, perche' il funding dei candidati non e' contato.
|
||||
|
||||
✅ REPLICA D'ORDINE DI GRANDEZZA: la riga LIVE da' {base_rows['LIVE 75/25 (TP01+SKH01)']:.0f}
|
||||
EUR/giorno su un conto funded da $100k, contro i "~EUR 15-30/g max" che il progetto pubblica dal
|
||||
25/07 per UN conto con cap $200k/trader. Macchineria diversa (qui una k iso-barriera, li' un MC
|
||||
con breach), stesso ordine di grandezza.
|
||||
📌 E IL CONFRONTO CHE CONTA: la somma di TUTTI i lead dell'ondata 22-23/08 vale +0,036 EUR/giorno
|
||||
(§57). Il solo AMPLIAMENTO DELL'INSIEME su un conto funded vale, come tetto,
|
||||
{d1:+.2f} / {d2:+.2f} EUR/giorno — cioe' 40-100x. Non e' un argomento per aprire un funded: e' un
|
||||
argomento per smettere di valutare il canale funded SOLO sul nozionale.""")
|
||||
|
||||
|
||||
# =============================================================================================
|
||||
# SEZ. 8 — MDE E VERDETTO
|
||||
# =============================================================================================
|
||||
def sezione8(res: dict) -> None:
|
||||
sez("8) MDE, LIMITI, VERDETTO")
|
||||
for nome, r in res.items():
|
||||
idx = r["cand"]["idx"]
|
||||
yrs = (idx[-1] - idx[0]) / pd.Timedelta("365.25D")
|
||||
print(f" {nome:<26} {yrs:.2f} anni -> SE(Sharpe) ~ {1/np.sqrt(yrs):.2f}, "
|
||||
f"MDE(95%) ~ {1.96/np.sqrt(yrs):.2f} di Sharpe")
|
||||
print("""
|
||||
Cio' che questo filone PUO' dire con questi dati: dove sta la soglia di eseguibilita' (e' una
|
||||
misura deterministica sul pavimento del venue, non una stima statistica, e non ha MDE).
|
||||
Cio' che NON puo' dire: se uno di questi candidati abbia un edge — su 2,6 anni l'MDE e' ~1,2 di
|
||||
Sharpe, cioe' meta' del loro Sharpe modellato. Non lo dico: lo dicono i gate gia' pubblicati.
|
||||
|
||||
LIMITI DICHIARATI
|
||||
- I 3 candidati misurati vivono su HYPERLIQUID. Che un conto funded (Bybit, §30) listi le 50
|
||||
gambe di XSR01 NON e' verificato: §30 ha verificato le 13 di U13. E' una GET pubblica: costa
|
||||
zero e va fatta prima di credere alla sez. 7.
|
||||
- `sim_libro` applica il pavimento per gamba e non modella il lotto minimo per-strumento HL
|
||||
(lotti $0,01-7,72 sui 19 major, sotto il pavimento $10 -> non binding). Sui 50 alt della coda
|
||||
non e' verificato strumento per strumento.
|
||||
- Lo slippage NON e' nel conto: HL-EXEC lo ha refutato come rischio #1 con margine 21x, ma su
|
||||
UNA fotografia di 172 secondi, e SLIP-AUDIT ha scritto che la partecipazione scala lineare
|
||||
-> a $100k la misura di attrito a $635 NON si estrapola. La sez. 7 va riletta a quella taglia.
|
||||
- Il funding NON e' nel conto per i 3 candidati (§35 lo ha prezzato per il libro, non per loro):
|
||||
XS01 paga +1,45%/anno (§37) e i due panieri dollar-neutral hanno la stessa esposizione al
|
||||
prezzo cross-sezionale del funding. Ogni EUR/giorno della sez. 7 e' quindi OTTIMISTA.""")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--no-net", action="store_true")
|
||||
a = ap.parse_args()
|
||||
t0 = time.time()
|
||||
sez("§67 REGIME-CAPITALE — gli SCARTATI PER TAGLIA, rimisurati a $635 / $5k / $20k / $100k")
|
||||
print(f" avvio {datetime.now(timezone.utc):%Y-%m-%d %H:%M:%S} UTC seed {SEED}")
|
||||
sola_lettura()
|
||||
print(f" parametri venue: Deribit min ${DER_MIN_ORDER:.0f} / {DER_FEE_SIDE*1e4:.2f} bps ; "
|
||||
f"Hyperliquid min ${HL_MIN_ORDER:.0f} / {HL_FEE_SIDE*1e4:.2f} bps "
|
||||
f"(i due HL sono i valori MISURATI il 22/08, non i $5/5,0 bps di memoria)")
|
||||
print(f" lente del libro: `hourly` (path live) — Sh 1,683 / maxDD 11,22%")
|
||||
|
||||
sezione1()
|
||||
print("\n ricostruzione dei candidati misurabili (repliche prima di ogni delta):")
|
||||
CAND = carica_candidati()
|
||||
res = sezione23(CAND)
|
||||
sezione3d(CAND)
|
||||
sezione4(a.no_net)
|
||||
sezione5(res)
|
||||
sezione6()
|
||||
sezione7(res)
|
||||
sezione8(res)
|
||||
|
||||
sez("VERDETTO")
|
||||
n = len(CENSIMENTO)
|
||||
n_edge = sum(1 for *_, e in CENSIMENTO if e.startswith("SI"))
|
||||
nf = sum(1 for _, _, _, st, _ in CENSIMENTO if st.startswith("FALSIFICATO"))
|
||||
print(f"""
|
||||
`A $100.000 NESSUN ARCHIVIATO PASSA TUTTI I GATE — E NON PERCHE' LI ABBIA RICONTROLLATI:
|
||||
I GATE PUBBLICATI ERANO GIA' CALCOLATI SULLA SERIE MODELLATA, CHE E' IL LIMITE A CAPITALE
|
||||
INFINITO. IL MURO DI TAGLIA NON NASCONDEVA NIENTE.`
|
||||
|
||||
Il censimento ha {n} voci; {n_edge} hanno ANCHE un rifiuto sull'edge. Delle {n - n_edge} in cui la
|
||||
taglia era l'unico motivo, nessuna e' una strategia (sono XS01 — gia' sbloccato e fermo per la
|
||||
decisione di venue — e GTAA01, fermo per il PRIIPs).
|
||||
Muri di taglia caduti: {nf} su {n}, tutti nell'ondata 22-23/08, tutti nella stessa direzione.
|
||||
Muri di taglia MISURATI QUI per la prima volta: STATARB-MULTI (C* $2.000-$7.500 secondo la
|
||||
tolleranza) e la curva completa di XSR01 col pavimento del venue GIUSTO (C* $15.000-$20.000,
|
||||
contro i ~$3.000 che HL-EXEC riportava con un criterio piu' permissivo).
|
||||
|
||||
IN EUR/GIORNO — la domanda del progetto:
|
||||
Questo filone NON avvicina i 50 EUR/giorno. Non aggiunge NIENTE al conto di oggi: tutto cio'
|
||||
che sblocca vive a capitali che il conto non ha, e a quei capitali resta bloccato sull'edge.
|
||||
Il suo contributo e' +0,000 EUR/giorno.
|
||||
Cio' che TOGLIE e' reale ma non e' reddito: il gate XSR01 del 23/10 legge un monitor tarato sul
|
||||
pavimento del venue sbagliato.
|
||||
Per confronto, sullo stesso motore: EUR 250 -> 500 al mese porta P(20 anni) dal 14% all'85%.
|
||||
|
||||
Libro, pesi, cron, config INVARIATI. Nessun ordine.
|
||||
durata {time.time()-t0:.0f} s""")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,909 @@
|
||||
"""r0823b_retry — §61 RETRY: la POLITICA DI RI-ACQUISTO del biglietto funded (2026-08-23).
|
||||
|
||||
IL BUCO CHE CHIUDE
|
||||
------------------
|
||||
Un conto funded che rompe una regola muore. Il progetto ha modellato tutto il resto del ciclo
|
||||
(prezzo, regole, leva, lente accoppiata, funding, morte-firm, fisco) e **mai la politica di
|
||||
RI-ACQUISTO**: quando ricomprare dopo un bust, con quali soldi, e con quale leva sul conto nuovo.
|
||||
Nei simulatori esistenti (`r0725_prop_ladder.simulate`, `r0725_prop_coupled.simulate`,
|
||||
`r0822d_gate_c.ladder`) la politica c'e' — e' **cablata**: *compra sempre, subito, il biglietto
|
||||
piu' GRANDE che la cassa permette, in tutti e 6 gli slot*. E' la politica piu' aggressiva della
|
||||
famiglia, non e' mai stata dichiarata come scelta, e **tutti i numeri operativi del canale funded
|
||||
escono da li'** (42% -> 7,8% -> 4,4% -> 2,6%).
|
||||
|
||||
E' diventata una domanda vera solo ieri, per due misure:
|
||||
(a) §30: la quota d'ingresso e' un **deposito RIMBORSABILE** ("Refundable Challenge Deposit,
|
||||
returned in full alongside your first funded payout") -> un tentativo fallito costa la
|
||||
quota, uno riuscito no. E' una struttura a OPZIONE, e le opzioni si comprano piu' volte.
|
||||
(b) §37: il biglietto batte il libro **solo perche' il piano di versamento c'e'**, cioe'
|
||||
**perche' si puo' giocare piu' di una volta** ("una lotteria a EV positivo che un conto da
|
||||
$654 puo' giocare UNA VOLTA SOLA").
|
||||
Se il valore sta nel NUMERO DI TENTATIVI, la politica di ri-acquisto e' la variabile principale
|
||||
e non e' mai stata ottimizzata.
|
||||
|
||||
LE ATTESE, REGISTRATE PRIMA DI MISURARE (poi riportate confermate/refutate)
|
||||
--------------------------------------------------------------------------
|
||||
A1. **Compromesso monotono.** IMMEDIATA massimizza sia il numero di giocate sia P(cassa a zero);
|
||||
MAI li minimizza entrambi. Nessuna politica dovrebbe dominare su tutte e due le colonne.
|
||||
A2. **La dose-risposta di §37 dovrebbe essere ripida.** Se il meccanismo e' "quante volte si
|
||||
gioca", passare da max 1 biglietto a illimitati deve muovere P(>=50 EUR/g) di molto. Se non
|
||||
lo muove, il meccanismo dichiarato da §37 e' sbagliato (o e' un'altra cosa).
|
||||
A3. **Il biglietto PICCOLO ($249/$25k) compra piu' giocate e perde sul bersaglio.** 50 EUR/g netti
|
||||
sono ~$59k di payout netti in 3 anni: con nozionale $25k servono troppi cicli. Mi aspetto
|
||||
P(zero) piu' bassa e P(>=50/g) piu' bassa. Dominato sul bersaglio, non sulla sopravvivenza.
|
||||
A4. **SOLO-PAYOUT ~= MAI senza versamenti** (senza payout non c'e' cassa per ricomprare) e
|
||||
molto piu' vicina a IMMEDIATA con versamenti.
|
||||
A5. **Il RIMBORSO alza i livelli di ~1-3pp (§37) ma NON cambia l'ordine delle politiche.**
|
||||
Previsione forte: l'ottimo e' lo stesso nelle tre convenzioni.
|
||||
A6. 🚨 **Le regole di leva condizionate all'esito passato sono NULL DEL DE-LEVERING.** In un
|
||||
bootstrap a blocchi il passato non porta informazione sul futuro: una regola "riduci la leva
|
||||
dopo un bust" puo' agire SOLO cambiando la leva MEDIA. Il controllo obbligatorio e' la leva
|
||||
COSTANTE alla stessa media realizzata. Mi aspetto REFUTED 3/3 (8ª occorrenza).
|
||||
A7. **La politica conta meno del versamento.** Mi aspetto uno spread fra politiche di pochi punti
|
||||
percentuali contro i ~+10pp del passaggio EUR 0 -> EUR 500/mese misurato da §37.
|
||||
|
||||
CONVENZIONI (tutte EREDITATE e congelate — nessuna scelta di strategia in questo file)
|
||||
--------------------------------------------------------------------------------------
|
||||
* Lente **ACCOPPIATA** (`r0725_prop_coupled`): su una regola a UN GIORNO la close-only e' cieca.
|
||||
* Conto funded = **W_A TP01 38 / SKH01 38 / XS01 25** (centro della regione robusta di §29),
|
||||
XS01 = **U13 Binance** fuori campione, finestra **W-LONG 2021+**, de-luck sul drift **x0,89**.
|
||||
* **Funding dentro** (§35/§37), morte-firm **10%/anno** (assunzione del progetto), cap
|
||||
**$200k/trader**, fisco **33%**, split **80%**, soglia di prelievo **$100** di quota trader.
|
||||
* Banda d'ancora: **23 offset x 3 fasi (0,3,7)** = lo stesso sottocampione dichiarato da §32/§37.
|
||||
La cella di riferimento e' la **MEDIANA** della banda, non la canonica (91° pctl).
|
||||
* Cassa non spesa: **FERMA** per default (convenzione di §37) e **SUL LIBRO** come sensibilita'
|
||||
dichiarata in §7 — perche' la convenzione "ferma" penalizza per costruzione le politiche
|
||||
prudenti, che sono esattamente quelle sotto esame.
|
||||
* Bootstrap **CONDIVISO** fra tutte le politiche di una stessa tabella -> confronti **APPAIATI**.
|
||||
|
||||
COSA NON E' QUESTO FILE: non e' una selezione di strategia (meccanismo, pesi, leva ottima, lente
|
||||
e soglie sono tutti ereditati); e' la mappatura di una politica OPERATIVA che finora era cablata.
|
||||
L'argmax su ~30 politiche resta pero' una selezione: si riportano il PLATEAU e la risoluzione MC.
|
||||
|
||||
Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_retry.py`
|
||||
Rete: NESSUNA (parquet certificati + cache Binance di r0822b + cache funding di r0822d).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv: # r0822d_funding legge USE_NET all'import
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata (25/07)
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm + scala di conti (25/07)
|
||||
import r0822_prop_alloc as PA # noqa: E402 J, bootstrap (22/08)
|
||||
import r0822b_prop_recal as PR # noqa: E402 PROP-RECAL (22/08)
|
||||
import r0822b_xs01_oos as X # noqa: E402 motore XS01 + cache Binance
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01 (gamba b)
|
||||
import r0822d_funding as FD # noqa: E402 il funding (22/08)
|
||||
import r0822d_gate_c as GC # noqa: E402 ladder di riferimento (§37)
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
EURUSD = pl.EURUSD
|
||||
TAX_RATE = pl.TAX_RATE
|
||||
SPLIT = pl.SPLIT
|
||||
DELUCK = PA.DELUCK
|
||||
W_A = GC.W_A
|
||||
OFFSETS = AP.OFFSETS
|
||||
PHASES_SUB = AP.PHASES_SUB
|
||||
MIN_PAYOUT = GC.MIN_PAYOUT_TRADER
|
||||
HORIZON_DAYS = GC.HORIZON_DAYS
|
||||
SEED_LAD = GC.SEED_LAD
|
||||
XS_FUND_ANN = 0.0145 # §37: XS01 PAGA +1,45%/anno di funding (misurato)
|
||||
|
||||
N_BAND = 1000 # percorsi per la banda d'ancora (riproduzione §32/§37)
|
||||
N_MAIN = 2000 # percorsi per la griglia di politiche (cella di rif.)
|
||||
N_ROB = 1000 # percorsi per la robustezza fra celle
|
||||
# Sottocampione di offset dichiarato A PRIORI: gli stessi 8 uniformi di `r0726_skh_live_book`
|
||||
# (la griglia piena e' 23; su 2 CPU condivise con altri 5 processi la piena non sta nel budget,
|
||||
# e un sottocampione uniforme dichiarato prima e' l'unica forma onesta di ridurla).
|
||||
BAND_OFFSETS = tuple(range(0, 690, 90))
|
||||
|
||||
# numeri PUBBLICATI da riprodurre prima di produrne di nuovi
|
||||
PUB = dict(anchor_p50g=0.044, anchor_p10=0.025, anchor_p90=0.082, anchor_pzero=0.353,
|
||||
gatec_p50g=0.026, gatec_p10=0.015, gatec_p90=0.047, gatec_pzero=0.403,
|
||||
refund_pp_lo=0.01, refund_pp_hi=0.03)
|
||||
|
||||
TRIALS = 0
|
||||
T0 = time.time()
|
||||
CHEAPEST = min(t[1] for F in pl.FIRMS for t in F["tickets"]) # $249
|
||||
|
||||
|
||||
def bump(n: int = 1) -> None:
|
||||
global TRIALS
|
||||
TRIALS += n
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "-" * 104)
|
||||
if t:
|
||||
print(f" {t}")
|
||||
print("-" * 104)
|
||||
|
||||
|
||||
def tick(lab: str) -> None:
|
||||
print(f" [{time.time() - T0:6.0f}s] {lab}", flush=True)
|
||||
|
||||
|
||||
# ============================================================================ LE POLITICHE
|
||||
def POL(when="immediate", k_reserve=1.0, cadence=0, max_tickets=10 ** 9, size="largest",
|
||||
lev_rule="const", lev_dn=1.0, lev_up=1.0, lev_lo=0.25, lev_hi=1.50,
|
||||
max_open=pl.MAX_CONCURRENT) -> dict:
|
||||
"""Una politica di ri-acquisto. `when`:
|
||||
immediate — compra appena uno slot e' libero e la cassa basta (= il CABLATO di oggi)
|
||||
threshold — compra solo se la cassa e' >= k_reserve x il prezzo (tiene una riserva)
|
||||
earned — il PRIMO biglietto dai propri soldi, i successivi SOLO dai payout/rimborsi
|
||||
cadence — al piu' un acquisto ogni `cadence` giorni
|
||||
none — non compra MAI (controllo positivo: deve dare P(>=50/g)=0)
|
||||
`size`: 'largest' (cablato) o 'cheapest' (piu' giocate, nozionale minore).
|
||||
`max_open`: quanti conti al MASSIMO possono essere aperti insieme (cablato: 6 = tutti gli
|
||||
slot). E' l'altra faccia del ri-acquisto: giocare in SERIE invece che in PARALLELO.
|
||||
`lev_rule`: 'const' | 'down_on_bust' (x lev_dn a ogni bust) | 'up_on_pass' (x lev_up a ogni
|
||||
pass). La leva di un conto e' fissata all'ACQUISTO e non cambia piu'."""
|
||||
return dict(when=when, k_reserve=k_reserve, cadence=cadence, max_tickets=max_tickets,
|
||||
size=size, lev_rule=lev_rule, lev_dn=lev_dn, lev_up=lev_up,
|
||||
lev_lo=lev_lo, lev_hi=lev_hi, max_open=max_open)
|
||||
|
||||
|
||||
P_BASE = POL() # il cablato, bit-exact vs §37
|
||||
|
||||
|
||||
# ============================================================================ IL SIMULATORE
|
||||
def ladder_rt(R, G, n_paths, lev, seed, *, pol=None, refund_mode="none", deposit_eur=0.0,
|
||||
start_eur=pl.START_EUR, min_payout=0.0, boot=None, block=20, deluck=DELUCK,
|
||||
rb_boot=None, tax=TAX_RATE) -> dict:
|
||||
"""`r0822d_gate_c.ladder` generalizzato alla POLITICA DI RI-ACQUISTO. Tre aggiunte:
|
||||
1. `pol` — quando/quale biglietto/con quali soldi/a che leva (sopra);
|
||||
2. `refund_mode` — 'none' (spesa persa, `pc.simulate`) | 'pass' (`r0725_hyro:200`) |
|
||||
'payout' (la regola vera della firm);
|
||||
3. `rb_boot` — se dato, la cassa NON spesa gira sul LIBRO LIVE invece di restare
|
||||
ferma, con lo STESSO sorteggio di bootstrap (stesso mercato) e lo
|
||||
stesso fisco annuale di `GC.book_road`.
|
||||
Con `pol=P_BASE, refund_mode='none', deposit_eur=0, min_payout=0, rb_boot=None` dev'essere
|
||||
**BIT-EXACT** rispetto a `GC.ladder(..., refund=False)` e quindi a `pc.simulate`: e' §1.
|
||||
|
||||
🚨 Zero e' ASSORBENTE ed e' modellato come tale: senza conti vivi e con cassa sotto il
|
||||
biglietto piu' economico ($249) non si gioca piu'; solo un versamento puo' riaprire il gioco.
|
||||
"""
|
||||
pol = pol or P_BASE
|
||||
rng = np.random.default_rng(seed)
|
||||
n_days = HORIZON_DAYS
|
||||
L = len(R)
|
||||
Rm = R.astype(float).reshape(-1, 1).copy()
|
||||
Gm = G.astype(float).reshape(-1, 1).copy()
|
||||
Rm = Rm - (1.0 - deluck) * Rm.mean(axis=0, keepdims=True)
|
||||
if boot is None:
|
||||
n_blocks = int(np.ceil(n_days / block))
|
||||
starts = rng.integers(0, L - block, size=(n_paths, n_blocks))
|
||||
idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days]
|
||||
else:
|
||||
idx = boot
|
||||
n_slot = pl.MAX_CONCURRENT
|
||||
# (paths, days): tutti gli slot girano lo STESSO libro -> una colonna basta. La leva
|
||||
# moltiplica per-slot (serve alle regole di leva) invece che globalmente: `x*lev` e' la
|
||||
# stessa moltiplicazione in virgola mobile, quindi il bit-exact regge (verificato in §1).
|
||||
Rb = Rm[idx][:, :, 0]
|
||||
Gb = Gm[idx][:, :, 0]
|
||||
|
||||
FIRMS = pl.FIRMS
|
||||
cash = np.full(n_paths, start_eur * EURUSD)
|
||||
basis = cash.copy()
|
||||
carry = np.zeros(n_paths)
|
||||
earned = np.zeros(n_paths) # borsellino dei soli payout/rimborsi
|
||||
phase = np.full((n_paths, n_slot), -1, np.int8)
|
||||
eq = np.ones((n_paths, n_slot))
|
||||
firm = np.full((n_paths, n_slot), -1, np.int8)
|
||||
notional = np.zeros((n_paths, n_slot))
|
||||
price_paid = np.zeros((n_paths, n_slot))
|
||||
refunded = np.zeros((n_paths, n_slot), bool)
|
||||
lev_slot = np.full((n_paths, n_slot), lev)
|
||||
# soglie della firm materializzate PER SLOT all'acquisto: la dinamica diventa una sola
|
||||
# espressione vettoriale invece di un loop sulle firm. Le maschere per firm sono disgiunte,
|
||||
# quindi il risultato e' identico (verificato bit-exact in §1).
|
||||
TH_TGT = np.zeros((n_paths, n_slot))
|
||||
TH_DD = np.ones((n_paths, n_slot))
|
||||
TH_DL = np.ones((n_paths, n_slot))
|
||||
TH_ML = np.ones((n_paths, n_slot))
|
||||
TH_DLF = np.ones((n_paths, n_slot))
|
||||
mult = np.ones(n_paths)
|
||||
firm_alive = np.ones((n_paths, len(FIRMS)), bool)
|
||||
cum_payout = np.zeros(n_paths)
|
||||
spent = np.zeros(n_paths)
|
||||
got_back = np.zeros(n_paths)
|
||||
deposited = np.zeros(n_paths)
|
||||
n_payouts = np.zeros(n_paths, int)
|
||||
n_tickets = np.zeros(n_paths, int)
|
||||
lev_sum = np.zeros(n_paths)
|
||||
last_buy = np.full(n_paths, -10 ** 9)
|
||||
days_out = np.zeros(n_paths, int)
|
||||
ever_passed = np.zeros(n_paths, bool)
|
||||
p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0)
|
||||
tickets_order = {}
|
||||
for fi, F in enumerate(FIRMS):
|
||||
tickets_order[fi] = sorted(F["tickets"], key=(lambda x: x[0]) if pol["size"] == "cheapest"
|
||||
else (lambda x: -x[0]))
|
||||
|
||||
for t in range(n_days):
|
||||
died = rng.random((n_paths, len(FIRMS))) < p_death_day
|
||||
newly_dead = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly_dead.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly_dead[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm == fi) & kill[:, None]
|
||||
phase[hit] = -1
|
||||
notional[hit] = 0.0
|
||||
|
||||
# ---------------------------------------------------------------- acquisti
|
||||
if pol["when"] == "none":
|
||||
budget = np.zeros(n_paths, int)
|
||||
elif pol["when"] == "cadence":
|
||||
budget = ((t - last_buy) >= pol["cadence"]).astype(int)
|
||||
else:
|
||||
budget = np.full(n_paths, n_slot, int)
|
||||
budget = np.minimum(budget, np.maximum(pol["max_tickets"] - n_tickets, 0))
|
||||
if pol["max_open"] < n_slot:
|
||||
budget = np.minimum(budget, np.maximum(pol["max_open"] - (phase >= 0).sum(axis=1), 0))
|
||||
if budget.any() and (cash >= CHEAPEST).any():
|
||||
for k in range(n_slot):
|
||||
free = (phase[:, k] == -1) & (budget > 0)
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
used = np.where(firm == fi, notional, 0.0).sum(axis=1)
|
||||
for (size, price) in tickets_order[fi]:
|
||||
buy = (free & firm_alive[:, fi] & (cash >= price)
|
||||
& (used + size <= F["cap"]))
|
||||
if pol["when"] == "threshold":
|
||||
buy &= cash >= pol["k_reserve"] * price
|
||||
elif pol["when"] == "earned":
|
||||
buy &= (n_tickets == 0) | (earned >= price)
|
||||
if not buy.any():
|
||||
continue
|
||||
cash[buy] -= price
|
||||
basis[buy] -= price
|
||||
if pol["when"] == "earned":
|
||||
take = buy & (n_tickets > 0)
|
||||
earned[take] -= price
|
||||
spent[buy] += price
|
||||
n_tickets[buy] += 1
|
||||
budget[buy] -= 1
|
||||
last_buy[buy] = t
|
||||
phase[buy, k] = 0
|
||||
eq[buy, k] = 1.0
|
||||
firm[buy, k] = fi
|
||||
notional[buy, k] = size
|
||||
price_paid[buy, k] = price
|
||||
refunded[buy, k] = False
|
||||
lv = np.clip(lev * mult, pol["lev_lo"], pol["lev_hi"])
|
||||
lev_slot[buy, k] = lv[buy]
|
||||
TH_TGT[buy, k], TH_DD[buy, k], TH_DL[buy, k] = F["ev"]
|
||||
TH_ML[buy, k], TH_DLF[buy, k] = F["fu"]
|
||||
lev_sum[buy] += lv[buy]
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
# ---------------------------------------------------------------- dinamica dei conti
|
||||
r = Rb[:, t][:, None] * lev_slot
|
||||
g = Gb[:, t][:, None] * lev_slot
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
|
||||
in_ev = act & (phase == 0)
|
||||
in_fu = act & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - TH_DD) | (r_low < -TH_DL)))
|
||||
| (in_fu & ((eq_low < 1.0 - TH_ML) | (r_low < -TH_DLF))))
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + TH_TGT) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
if pol["lev_rule"] == "down_on_bust":
|
||||
mult *= pol["lev_dn"] ** bust.sum(axis=1)
|
||||
elif pol["lev_rule"] == "up_on_pass":
|
||||
mult *= pol["lev_up"] ** passed.sum(axis=1)
|
||||
if refund_mode == "pass" and passed.any():
|
||||
back = passed & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
basis += amt
|
||||
earned += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
ever_passed |= passed.any(axis=1)
|
||||
|
||||
# ---------------------------------------------------------------- la cassa propria
|
||||
if rb_boot is not None:
|
||||
cash = np.maximum(cash * (1.0 + rb_boot[:, t]), 0.0)
|
||||
|
||||
# ---------------------------------------------------------------- mensile
|
||||
if (t + 1) % 30 == 0:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout)
|
||||
gain = np.where(pay, (eq - 1.0) * notional, 0.0)
|
||||
net = gain.sum(axis=1) * SPLIT * (1.0 - TAX_RATE)
|
||||
cum_payout += net
|
||||
cash += net
|
||||
basis += net
|
||||
earned += net
|
||||
n_payouts += (pay.sum(axis=1) > 0).astype(int)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund_mode == "payout":
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
basis += amt
|
||||
earned += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
if deposit_eur:
|
||||
cash += deposit_eur * EURUSD
|
||||
basis += deposit_eur * EURUSD
|
||||
deposited += deposit_eur * EURUSD
|
||||
# fisco annuale sulla sola cassa propria (i payout sono gia' netti)
|
||||
if rb_boot is not None and (t + 1) % 365 == 0:
|
||||
gtax = (cash - basis) + carry
|
||||
due = np.where(gtax > 0, tax * gtax, 0.0)
|
||||
carry = np.where(gtax > 0, 0.0, gtax)
|
||||
cash = cash - due
|
||||
basis = cash.copy()
|
||||
|
||||
out = (~(phase >= 0).any(axis=1)) & (cash < CHEAPEST)
|
||||
days_out += out
|
||||
|
||||
eur_day = cum_payout / EURUSD / (n_days / 365.0) / 365.0
|
||||
stuck = (~(phase >= 0).any(axis=1)) & (cash < CHEAPEST)
|
||||
return dict(eur_day=eur_day, med=float(np.median(eur_day)),
|
||||
p10=float(np.percentile(eur_day, 10)), p90=float(np.percentile(eur_day, 90)),
|
||||
mean_eur=float(eur_day.mean()),
|
||||
p_ge10=float((eur_day >= 10.0).mean()),
|
||||
p_target=float((eur_day >= pl.TARGET_EUR_DAY).mean()),
|
||||
p_zero=float((cum_payout <= 0).mean()),
|
||||
p_payout=float((n_payouts > 0).mean()),
|
||||
p_pass=float(ever_passed.mean()),
|
||||
p_stuck=float(stuck.mean()),
|
||||
n_tix=n_tickets, med_tix=float(np.median(n_tickets)),
|
||||
mean_tix=float(n_tickets.mean()),
|
||||
lev_mean=float(lev_sum.sum() / max(n_tickets.sum(), 1)),
|
||||
days_out=float(np.median(days_out)),
|
||||
cash=cash, med_cash=float(np.median(cash)), mean_cash=float(cash.mean()),
|
||||
p10_cash=float(np.percentile(cash, 10)),
|
||||
p90_cash=float(np.percentile(cash, 90)),
|
||||
med_spent=float(np.median(spent)), mean_back=float(got_back.mean()),
|
||||
contributed=float(start_eur * EURUSD + deposited.mean()))
|
||||
|
||||
|
||||
def se_pair(a: np.ndarray, b: np.ndarray, thr: float = pl.TARGET_EUR_DAY) -> float:
|
||||
"""SE della DIFFERENZA fra due proporzioni APPAIATE (stessi sorteggi): McNemar.
|
||||
Con bootstrap condiviso la parte comune si cancella e la risoluzione e' molto migliore
|
||||
di quella dei livelli — ma non e' zero, e va stampata."""
|
||||
A = a >= thr
|
||||
B = b >= thr
|
||||
n01 = float((A & ~B).sum())
|
||||
n10 = float((~A & B).sum())
|
||||
n = len(a)
|
||||
return float(np.sqrt(max(n01 + n10 - (n01 - n10) ** 2 / n, 0.0)) / n)
|
||||
|
||||
|
||||
# ==================================================================================== main
|
||||
def main() -> None:
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
print("=" * 104)
|
||||
print(" §61 RETRY — la POLITICA DI RI-ACQUISTO del biglietto funded, mappata invece che")
|
||||
print(" cablata. Quando ricomprare, con quali soldi, a che leva — e quanto conta.")
|
||||
print("=" * 104)
|
||||
print(" ATTESE REGISTRATE PRIMA: A1 compromesso monotono giocate/rovina; A2 dose-risposta")
|
||||
print(" RIPIDA se il meccanismo di §37 e' 'il numero di volte che si gioca'; A3 biglietto")
|
||||
print(" piccolo = piu' giocate, meno bersaglio; A4 SOLO-PAYOUT ~= MAI senza versamenti;")
|
||||
print(" A5 il rimborso NON cambia l'ottimo; A6 le regole di leva sono null del de-levering")
|
||||
print(" (REFUTED 3/3 atteso); A7 la politica conta meno del versamento.")
|
||||
|
||||
# ============================================================== §0 pannello
|
||||
hr("§0. IL PANNELLO — le stesse serie di §29/§37 (U13 Binance, W-LONG 2021+, funding dentro)")
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
print(" !! cache funding assente: il filone si ferma. Un numero senza funding NON e'")
|
||||
print(" confrontabile con §37, e confrontarlo sarebbe l'errore che §35 ha appena")
|
||||
print(" pagato. 'non misurabile' e' un risultato.")
|
||||
return
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13 = Ob.reindex(p13.index)[X.U13]
|
||||
h13 = Hb.reindex(p13.index)[X.U13]
|
||||
l13 = Lb.reindex(p13.index)[X.U13]
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES_SUB}
|
||||
xs0 = XSP[PHASES_SUB[0]]
|
||||
base = pc.crypto_daily_tuples(1.0, 0.0).index.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
I = base[base >= max(first13, pd.Timestamp("2021-01-01", tz="UTC"))]
|
||||
pc.DELUCK = DELUCK
|
||||
print(f" W-LONG: {len(I)} giorni {I[0].date()} -> {I[-1].date()} | de-luck x{DELUCK} | "
|
||||
f"cassa iniziale EUR {pl.START_EUR:.0f} = ${pl.START_EUR*EURUSD:,.0f}")
|
||||
print(f" orizzonte {HORIZON_DAYS} giorni ({HORIZON_DAYS/30:.0f} versamenti da 30 giorni: "
|
||||
f"§57 avverte che 'EUR X/mese' qui vuol dire ogni 30 giorni — su 36 mesi torna esatto)")
|
||||
print(f" biglietti disponibili: " + " | ".join(
|
||||
f"{F['name']} " + ", ".join(f"${s/1000:.0f}k@${p:.0f}" for s, p in F['tickets'])
|
||||
for F in pl.FIRMS))
|
||||
print(f" biglietto piu' economico ${CHEAPEST:.0f} -> sotto questa cassa e senza conti vivi")
|
||||
print(f" il percorso e' FUORI GIOCO (zero assorbente).")
|
||||
tick("§0")
|
||||
|
||||
# ============================================================== §1 controlli
|
||||
hr("§1. CONTROLLI — bit-exact contro il simulatore pubblicato, e il controllo POSITIVO")
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[0], 0)
|
||||
f0 = GC.fvec_for(W_A, I, rate, 0, XS_FUND_ANN)
|
||||
Rc0 = R0 - f0
|
||||
print(" §1.1 la mia `ladder_rt` col cablato (immediate/largest/const, nessun rimborso,")
|
||||
print(" nessun versamento, soglia 0, cassa ferma) contro `GC.ladder` di §37:")
|
||||
a = GC.ladder(Rc0, G0, N_BAND, 0.75, SEED_LAD, refund=False)
|
||||
b = ladder_rt(Rc0, G0, N_BAND, 0.75, SEED_LAD, pol=P_BASE)
|
||||
d1 = float(np.abs(a["eur_day"] - b["eur_day"]).max())
|
||||
print(f" max|diff| percorso per percorso = {d1:.3e} -> "
|
||||
f"{'IDENTICO' if d1 < 1e-15 else 'DIVERGE — STOP'}")
|
||||
if d1 >= 1e-15:
|
||||
print(" Senza questo controllo i numeri sotto sarebbero di un'altra macchina.")
|
||||
return
|
||||
bump(2)
|
||||
print("\n §1.2 e `GC.ladder` e' a sua volta bit-exact contro `pc.simulate` (§37 §4.1);")
|
||||
print(" la catena e' quindi: ladder_rt == GC.ladder == pc.simulate.")
|
||||
cfg = tuple(W_A.get(n, 0.0) for n in PA.CRYPTO_PROP)
|
||||
key = (cfg[0], cfg[1], cfg[2], "shared")
|
||||
saved = pc._TUP_CACHE.pop(key, None)
|
||||
pc._TUP_CACHE[key] = (Rc0, G0, I)
|
||||
ref = pc.simulate([cfg], [0] * pl.MAX_CONCURRENT, n_paths=N_BAND, lev=0.75,
|
||||
seed=SEED_LAD, lens="coupled", start=str(I[0].date()))
|
||||
pc._TUP_CACHE.pop(key, None)
|
||||
if saved is not None:
|
||||
pc._TUP_CACHE[key] = saved
|
||||
d2 = float(np.abs(ref["eur_day"] - b["eur_day"]).max())
|
||||
print(f" max|diff| ladder_rt vs pc.simulate = {d2:.3e} -> "
|
||||
f"{'IDENTICO' if d2 < 1e-15 else 'DIVERGE'}")
|
||||
bump(1)
|
||||
|
||||
print("\n §1.3 CONTROLLO POSITIVO del selettore di politica — un interruttore che non")
|
||||
print(" cambia niente e' indistinguibile da un interruttore rotto.")
|
||||
rngb = np.random.default_rng(51224)
|
||||
nb = int(np.ceil(HORIZON_DAYS / 20))
|
||||
st = rngb.integers(0, len(I) - 20, size=(N_MAIN, nb))
|
||||
BOOT = (st[:, :, None] + np.arange(20)[None, None, :]).reshape(N_MAIN, -1)[:, :HORIZON_DAYS]
|
||||
rb_full = FD.book_75_25(rate, alloc=654.0)
|
||||
if rb_full.index.tz is None:
|
||||
rb_full.index = rb_full.index.tz_localize("UTC")
|
||||
rb = np.nan_to_num(rb_full.reindex(I).values.astype(float))
|
||||
rb_dl = rb - (1.0 - DELUCK) * rb.mean()
|
||||
RB_BOOT = rb_dl[BOOT]
|
||||
none_pol = ladder_rt(Rc0, G0, N_MAIN, 0.75, SEED_LAD, pol=POL(when="none"), boot=BOOT)
|
||||
bump(1)
|
||||
print(f" politica 'MAI COMPRARE': biglietti mediani {none_pol['med_tix']:.0f}, "
|
||||
f"P(>=50/g) {none_pol['p_target']:.1%}, P(zero payout) {none_pol['p_zero']:.1%} -> "
|
||||
f"{'OK' if none_pol['p_target'] == 0 and none_pol['p_zero'] == 1 else 'ROTTO'}")
|
||||
print("\n §1.4 CONTROLLO POSITIVO della cassa-sul-libro: 'MAI COMPRARE' + cassa sul libro")
|
||||
print(" dev'essere la strada LIBRO di §37 (`GC.book_road`), stessi sorteggi.")
|
||||
nb_book = ladder_rt(Rc0, G0, N_MAIN, 0.75, SEED_LAD, pol=POL(when="none"), boot=BOOT,
|
||||
rb_boot=RB_BOOT)
|
||||
road = GC.book_road(rb, BOOT, pl.START_EUR, 0.0)
|
||||
d3 = float(np.abs(nb_book["cash"] - road["cash"]).max())
|
||||
bump(2)
|
||||
print(f" max|diff| sulla cassa finale = {d3:.3e} -> "
|
||||
f"{'IDENTICO' if d3 < 1e-9 else 'DIVERGE'} | mediana ${nb_book['med_cash']:,.0f} "
|
||||
f"(GC.book_road ${road['med_cash']:,.0f})")
|
||||
tick("§1")
|
||||
|
||||
# ============================================================== §2 banda d'ancora
|
||||
hr("§2. LA BANDA D'ANCORA — riproduzione di §32/§37 e scelta della cella MEDIANA")
|
||||
print(f" {len(BAND_OFFSETS)} offset (sottocampione uniforme a priori di r0726, la griglia")
|
||||
print(f" piena e' 23) x {len(PHASES_SUB)} fasi {PHASES_SUB} = "
|
||||
f"{len(BAND_OFFSETS)*len(PHASES_SUB)} celle, funding DENTRO, politica CABLATA (quella")
|
||||
print(f" con cui i numeri sono stati pubblicati), {N_BAND} percorsi per cella.")
|
||||
ev_b = PA.boot_idx(len(I), GC.EV_H, PA.N_PATHS, seed=GC.SEED_EV)
|
||||
fu_b = PA.boot_idx(len(I), GC.FU_H, PA.N_PATHS, seed=GC.SEED_FU)
|
||||
cells = []
|
||||
for off in BAND_OFFSETS:
|
||||
fA = GC.fvec_for(W_A, I, rate, off, XS_FUND_ANN)
|
||||
for ph in PHASES_SUB:
|
||||
Rx, Gx = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rf = Rx - fA
|
||||
j, lv, _ = GC.best_lev(Rf, Gx, ev_b, fu_b)
|
||||
lad = ladder_rt(Rf, Gx, N_BAND, lv, SEED_LAD, pol=P_BASE)
|
||||
cells.append(dict(off=off, ph=ph, J=j, lev=lv, p50=lad["p_target"],
|
||||
pz=lad["p_zero"], med=lad["med"]))
|
||||
bump(1)
|
||||
C = pd.DataFrame(cells)
|
||||
print(f"\n P(>=50 EUR/g) mediana {C['p50'].median():.1%} (PUB §37 {PUB['gatec_p50g']:.1%}) | "
|
||||
f"banda [{np.percentile(C['p50'],10):.1%}, {np.percentile(C['p50'],90):.1%}] "
|
||||
f"(PUB [{PUB['gatec_p10']:.1%}, {PUB['gatec_p90']:.1%}]) | "
|
||||
f"P(zero) {C['pz'].median():.1%} (PUB {PUB['gatec_pzero']:.1%})")
|
||||
can = C[(C["off"] == 0) & (C["ph"] == 0)].iloc[0]
|
||||
pct_can = float((C["p50"] <= can["p50"]).mean())
|
||||
print(f" cella CANONICA (off 0, fase 0): P(>=50/g) {can['p50']:.1%} = {pct_can:.0%}° pctl "
|
||||
f"della banda -> il gia' noto: la canonica e' la cella FORTUNATA, non la stima.")
|
||||
k_med = int((C["p50"] - C["p50"].median()).abs().idxmin())
|
||||
OFF_M, PH_M, LEV_M = int(C.loc[k_med, "off"]), int(C.loc[k_med, "ph"]), float(C.loc[k_med, "lev"])
|
||||
print(f" CELLA DI RIFERIMENTO (mediana della banda): offset {OFF_M} min, fase {PH_M}, "
|
||||
f"leva {LEV_M:.2f}x, P(>=50/g) {C.loc[k_med,'p50']:.1%}")
|
||||
fM = GC.fvec_for(W_A, I, rate, OFF_M, XS_FUND_ANN)
|
||||
RxM, G_M = AP.rg_off(W_A, I, XSP[PH_M], OFF_M)
|
||||
R_M = RxM - fM
|
||||
tick("§2")
|
||||
|
||||
# ============================================================== §3 dose-risposta
|
||||
hr("§3. QUANTE VOLTE SI GIOCA — la dose-risposta che §37 dichiara come IL meccanismo")
|
||||
print(" Politica IMMEDIATA (il cablato) con un tetto DURO al numero di biglietti mai")
|
||||
print(" comprati. E' l'esperimento pulito: cambia SOLO quante volte si puo' giocare.")
|
||||
print(f" Cella di riferimento, {N_MAIN} percorsi, bootstrap condiviso, deposito rimborsato")
|
||||
print(" al primo payout (la regola vera), soglia di prelievo $100, nessun versamento.")
|
||||
print(f"\n {'tetto':>8} {'giocate med':>12} {'giocate medie':>14} {'P(>=50/g)':>10} "
|
||||
f"{'P(>=10/g)':>10} {'P(zero payout)':>15} {'P(fuori gioco)':>15} {'EUR/g medio':>12}")
|
||||
dose = {}
|
||||
for mt in (1, 2, 3, 5, 8, 10 ** 9):
|
||||
r = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=POL(max_tickets=mt),
|
||||
refund_mode="payout", min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
dose[mt] = r
|
||||
bump(1)
|
||||
lab = "illim." if mt > 100 else str(mt)
|
||||
print(f" {lab:>8} {r['med_tix']:>12.0f} {r['mean_tix']:>14.2f} {r['p_target']:>10.1%} "
|
||||
f"{r['p_ge10']:>10.1%} {r['p_zero']:>15.1%} {r['p_stuck']:>15.1%} "
|
||||
f"{r['mean_eur']:>12.2f}")
|
||||
d1_, dinf = dose[1], dose[10 ** 9]
|
||||
se = se_pair(dinf["eur_day"], d1_["eur_day"])
|
||||
print(f"\n DA 1 GIOCATA A ILLIMITATE: P(>=50/g) {d1_['p_target']:.1%} -> "
|
||||
f"{dinf['p_target']:.1%} ({(dinf['p_target']-d1_['p_target'])*100:+.2f}pp, "
|
||||
f"SE appaiata {se*100:.2f}pp) | giocate mediane {d1_['med_tix']:.0f} -> "
|
||||
f"{dinf['med_tix']:.0f} | P(zero) {d1_['p_zero']:.1%} -> {dinf['p_zero']:.1%}")
|
||||
ripida = (dinf["p_target"] - d1_["p_target"]) > 3 * se
|
||||
print(f" >>> ATTESA A2 ('dose-risposta RIPIDA se il meccanismo e' il numero di giocate'): "
|
||||
f"{'CONFERMATA' if ripida else 'REFUTATA'}")
|
||||
tick("§3")
|
||||
|
||||
# ============================================================== §4 le politiche
|
||||
hr("§4. LE POLITICHE DI RI-ACQUISTO — 7 regole di TEMPO x 2 di TAGLIA, senza versamenti")
|
||||
print(" Le due colonne che vanno SEMPRE lette insieme: 'giocate' e 'P(fuori gioco)'. Una")
|
||||
print(" politica aggressiva aumenta entrambe, ed e' esattamente la trappola dichiarata.")
|
||||
print("\n Prima di misurare, l'ARITMETICA del listino — prezzo per $1.000 di nozionale:")
|
||||
for F in pl.FIRMS:
|
||||
print(" " + f"{F['name']:>5} " + " ".join(
|
||||
f"${s_/1000:.0f}k: ${p_/(s_/1000):.2f}/k" for s_, p_ in F["tickets"]))
|
||||
print(" -> il biglietto GRANDE costa MENO per unita' di nozionale (HYRO $5,79/k contro")
|
||||
print(" $9,96/k). Piu' giocate piccole NON sono piu' esposizione: sono meno.")
|
||||
POLS = [
|
||||
("IMMEDIATA (il cablato)", POL()),
|
||||
("SOGLIA 2x il prezzo", POL(when="threshold", k_reserve=2.0)),
|
||||
("SOGLIA 3x il prezzo", POL(when="threshold", k_reserve=3.0)),
|
||||
("SOLO DAI PAYOUT", POL(when="earned")),
|
||||
("CADENZA 90 giorni", POL(when="cadence", cadence=90)),
|
||||
("CADENZA 180 giorni", POL(when="cadence", cadence=180)),
|
||||
("UN CONTO ALLA VOLTA", POL(max_open=1)),
|
||||
("DUE CONTI ALLA VOLTA", POL(max_open=2)),
|
||||
("MAI (1 biglietto)", POL(max_tickets=1)),
|
||||
]
|
||||
res4 = {}
|
||||
for size in ("largest", "cheapest"):
|
||||
lab_s = "biglietto PIU' GRANDE ($100k)" if size == "largest" else "biglietto PIU' ECONOMICO ($25k)"
|
||||
print(f"\n --- {lab_s} ---")
|
||||
print(f" {'politica':>26} {'giocate med':>12} {'P(>=50/g)':>10} {'P(>=10/g)':>10} "
|
||||
f"{'P(zero)':>9} {'P(fuori gioco)':>15} {'EUR/g med':>10} {'cassa fin. med':>15}")
|
||||
for name, p in POLS:
|
||||
pp = dict(p)
|
||||
pp["size"] = size
|
||||
r = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=pp, refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
res4[(size, name)] = r
|
||||
bump(1)
|
||||
print(f" {name:>26} {r['med_tix']:>12.0f} {r['p_target']:>10.1%} "
|
||||
f"{r['p_ge10']:>10.1%} {r['p_zero']:>9.1%} {r['p_stuck']:>15.1%} "
|
||||
f"{r['med']:>10.2f} ${r['med_cash']:>14,.0f}")
|
||||
base_r = res4[("largest", "IMMEDIATA (il cablato)")]
|
||||
print(f"\n DIFFERENZE APPAIATE contro il cablato (stessi sorteggi), su P(>=50 EUR/g):")
|
||||
print(f" {'politica':>26} {'dP(>=50/g)':>12} {'SE appaiata':>13} {'dP(fuori gioco)':>17} "
|
||||
f"{'d giocate med':>14}")
|
||||
rows4 = []
|
||||
for size in ("largest", "cheapest"):
|
||||
for name, _ in POLS:
|
||||
r = res4[(size, name)]
|
||||
if (size, name) == ("largest", "IMMEDIATA (il cablato)"):
|
||||
continue
|
||||
s = se_pair(r["eur_day"], base_r["eur_day"])
|
||||
tag = name if size == "largest" else "[pic] " + name
|
||||
rows4.append(dict(tag=tag, d=r["p_target"] - base_r["p_target"], se=s,
|
||||
dz=r["p_stuck"] - base_r["p_stuck"],
|
||||
dt=r["med_tix"] - base_r["med_tix"], p50=r["p_target"],
|
||||
pstuck=r["p_stuck"]))
|
||||
print(f" {tag:>26} {(r['p_target']-base_r['p_target'])*100:>11.2f}pp "
|
||||
f"{s*100:>12.2f}pp {(r['p_stuck']-base_r['p_stuck'])*100:>16.2f}pp "
|
||||
f"{r['med_tix']-base_r['med_tix']:>14.0f}")
|
||||
R4 = pd.DataFrame(rows4)
|
||||
sig = R4[R4["d"].abs() > 2 * R4["se"]]
|
||||
print(f"\n Politiche che si distinguono dal cablato oltre 2 SE appaiate: "
|
||||
f"{len(sig)}/{len(R4)}"
|
||||
+ (f" (fra cui {', '.join(list(sig['tag'].str.strip())[:4])}...)" if len(sig) else ""))
|
||||
allp = pd.concat([R4[["tag", "p50", "pstuck"]],
|
||||
pd.DataFrame([dict(tag="IMMEDIATA (il cablato)", p50=base_r["p_target"],
|
||||
pstuck=base_r["p_stuck"])])], ignore_index=True)
|
||||
print(f" Spread fra la politica migliore e la peggiore su P(>=50/g): "
|
||||
f"{(allp['p50'].max()-allp['p50'].min())*100:.2f}pp "
|
||||
f"(max {allp.loc[allp['p50'].idxmax(),'tag'].strip()} {allp['p50'].max():.1%}, "
|
||||
f"min {allp.loc[allp['p50'].idxmin(),'tag'].strip()} {allp['p50'].min():.1%})")
|
||||
s3 = res4[("largest", "SOGLIA 3x il prezzo")]
|
||||
print(f"\n ⚠ A $654 la SOGLIA 3x e' degenere: il biglietto piu' economico costa ${CHEAPEST:.0f}")
|
||||
print(f" e 3x sono ${3*CHEAPEST:.0f} > ${pl.START_EUR*EURUSD:,.0f} -> giocate mediane "
|
||||
f"{s3['med_tix']:.0f}. Non e' una politica prudente, e' 'non giocare' scritta")
|
||||
print(f" con un'altra sintassi. La soglia in VALUTA ASSOLUTA dipende dal capitale:")
|
||||
print(f" stessa lezione della banda di GTAA01 (27/07), su un altro parametro.")
|
||||
pic = res4[("cheapest", "IMMEDIATA (il cablato)")]
|
||||
a3a = pic["p_target"] < base_r["p_target"]
|
||||
a3b = pic["p_stuck"] < base_r["p_stuck"]
|
||||
print(f"\n >>> ATTESA A3: il biglietto piccolo perde sul bersaglio "
|
||||
f"({pic['p_target']:.1%} contro {base_r['p_target']:.1%}) -> "
|
||||
f"{'confermata' if a3a else 'REFUTATA'}; e sulla ROVINA "
|
||||
f"({pic['p_stuck']:.1%} contro {base_r['p_stuck']:.1%}) -> "
|
||||
f"{'confermata' if a3b else 'REFUTATA'}. Verdetto A3: "
|
||||
f"{'CONFERMATA' if (a3a and a3b) else 'PARZIALE/REFUTATA'}")
|
||||
tick("§4")
|
||||
|
||||
# ============================================================== §5 la leva
|
||||
hr("§5. LA LEVA DEL CONTO NUOVO — e il NULL DEL DE-LEVERING, dichiarato PRIMA")
|
||||
print(" 🚨 In un bootstrap a blocchi il passato NON porta informazione sul futuro: una")
|
||||
print(" regola 'riduci la leva dopo un bust' puo' agire SOLO cambiando la leva MEDIA. Il")
|
||||
print(" controllo obbligatorio e' la leva COSTANTE alla stessa media realizzata. Se la")
|
||||
print(" regola non la batte, e' de-levering travestito (sarebbe l'8ª occorrenza).")
|
||||
lev_rules = [
|
||||
("costante (il cablato)", POL()),
|
||||
("RIDOTTA x0,80 a ogni bust", POL(lev_rule="down_on_bust", lev_dn=0.80)),
|
||||
("RIDOTTA x0,60 a ogni bust", POL(lev_rule="down_on_bust", lev_dn=0.60)),
|
||||
("CRESCENTE x1,25 a ogni pass", POL(lev_rule="up_on_pass", lev_up=1.25)),
|
||||
]
|
||||
print(f"\n {'regola di leva':>30} {'leva media':>11} {'P(>=50/g)':>10} {'P(zero)':>9} "
|
||||
f"{'P(fuori gioco)':>15} {'EUR/g medio':>12}")
|
||||
lev_res = {}
|
||||
for name, p in lev_rules:
|
||||
r = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=p, refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
lev_res[name] = r
|
||||
bump(1)
|
||||
print(f" {name:>30} {r['lev_mean']:>11.3f} {r['p_target']:>10.1%} {r['p_zero']:>9.1%} "
|
||||
f"{r['p_stuck']:>15.1%} {r['mean_eur']:>12.2f}")
|
||||
print(f"\n IL NULL: leva COSTANTE alla stessa media realizzata di ciascuna regola")
|
||||
print(f" {'regola':>30} {'leva cost.':>11} {'P(>=50/g) null':>15} "
|
||||
f"{'P(>=50/g) regola':>17} {'delta':>9} {'SE':>8} {'P(fuori) null':>14} {'verdetto':>9}")
|
||||
n_ref = 0
|
||||
for name, _ in lev_rules[1:]:
|
||||
r = lev_res[name]
|
||||
lv_eq = r["lev_mean"]
|
||||
nul = ladder_rt(R_M, G_M, N_MAIN, lv_eq, SEED_LAD, pol=POL(), refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
bump(1)
|
||||
d = r["p_target"] - nul["p_target"]
|
||||
s = se_pair(r["eur_day"], nul["eur_day"])
|
||||
ok = d > 2 * s
|
||||
n_ref += 0 if ok else 1
|
||||
print(f" {name:>30} {lv_eq:>11.3f} {nul['p_target']:>15.1%} {r['p_target']:>17.1%} "
|
||||
f"{d*100:>8.2f}pp {s*100:>7.2f}pp {nul['p_stuck']:>14.1%} "
|
||||
f"{'BATTE' if ok else 'REFUTED':>9}")
|
||||
print(f"\n >>> ATTESA A6 ('null del de-levering, REFUTED 3/3'): "
|
||||
f"{'CONFERMATA' if n_ref == 3 else f'PARZIALE ({n_ref}/3 refutate)'}")
|
||||
print(" Lettura: la leva del conto nuovo non e' una politica, e' un LIVELLO — e il livello")
|
||||
print(" ottimo e' gia' cercato simmetricamente da `best_lev` in ogni cella (§29).")
|
||||
print("\n §5.1 DIAGNOSTICO (non una proposta): il LIVELLO di leva, costante, spazzato sulla")
|
||||
print(" stessa griglia LEVS di §29. `best_lev` massimizza J = P(pass) x P(vivo), NON")
|
||||
print(" P(>=50 EUR/g): §29 lo dichiara ('J e P(>=50/g) hanno argmax diversi'). Sceglierla")
|
||||
print(" qui sul bersaglio sarebbe selezione sulla metrica d'uscita — si mostra il PREZZO.")
|
||||
print(f"\n {'leva':>8} {'P(>=50/g)':>10} {'P(>=10/g)':>10} {'P(zero payout)':>15} "
|
||||
f"{'P(fuori gioco)':>15} {'EUR/g medio':>12} {'EUR/g mediano':>14}")
|
||||
for lv in PR.LEVS:
|
||||
r = ladder_rt(R_M, G_M, N_MAIN, lv, SEED_LAD, pol=POL(), refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
bump(1)
|
||||
star = " <- best_lev (J)" if abs(lv - LEV_M) < 1e-9 else ""
|
||||
print(f" {lv:>8.3f} {r['p_target']:>10.1%} {r['p_ge10']:>10.1%} {r['p_zero']:>15.1%} "
|
||||
f"{r['p_stuck']:>15.1%} {r['mean_eur']:>12.2f} {r['med']:>14.2f}{star}")
|
||||
tick("§5")
|
||||
|
||||
# ============================================================== §6 le tre convenzioni
|
||||
hr("§6. LE TRE CONVENZIONI SUL DEPOSITO — cambia l'OTTIMO, o solo il livello?")
|
||||
print(" (i) SPESA PERSA `pc.simulate` — da cui esce il numero operativo del progetto;")
|
||||
print(" (ii) RIMBORSO AL PASS `r0725_hyro:200` — l'altro modello, contraddittorio;")
|
||||
print(" (iii) RIMBORSO AL PRIMO PAYOUT — la regola dichiarata dalla firm (§30).")
|
||||
sel6 = ["IMMEDIATA (il cablato)", "SOGLIA 2x il prezzo", "SOLO DAI PAYOUT",
|
||||
"CADENZA 180 giorni", "MAI (1 biglietto)"]
|
||||
conv = [("(i) spesa persa", "none"), ("(ii) al pass", "pass"), ("(iii) al primo payout", "payout")]
|
||||
tab6 = {}
|
||||
print(f"\n {'politica':>26} " + " ".join(f"{c[0]:>22}" for c in conv))
|
||||
for name in sel6:
|
||||
p = dict([x for x in POLS if x[0] == name][0][1])
|
||||
line = f" {name:>26} "
|
||||
for lab, rm in conv:
|
||||
r = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=p, refund_mode=rm,
|
||||
min_payout=MIN_PAYOUT, boot=BOOT)
|
||||
tab6[(name, rm)] = r
|
||||
bump(1)
|
||||
line += f"{r['p_target']:>10.1%}/{r['p_stuck']:>9.1%} "
|
||||
print(line + " <- P(>=50/g) / P(fuori gioco)")
|
||||
print("\n ARGMAX per convenzione (su P(>=50 EUR/g)):")
|
||||
same = True
|
||||
arg0 = None
|
||||
for lab, rm in conv:
|
||||
vals = {n: tab6[(n, rm)]["p_target"] for n in sel6}
|
||||
arg = max(vals, key=vals.get)
|
||||
if arg0 is None:
|
||||
arg0 = arg
|
||||
same &= (arg == arg0)
|
||||
print(f" {lab:>22}: {arg:>26} ({vals[arg]:.1%})")
|
||||
dpp = np.median([tab6[(n, "payout")]["p_target"] - tab6[(n, "none")]["p_target"] for n in sel6])
|
||||
print(f"\n Valore del rimborso (mediana su {len(sel6)} politiche, da 'spesa persa' a")
|
||||
print(f" 'rimborso al primo payout'): {dpp*100:+.2f}pp su P(>=50/g) "
|
||||
f"(PUB §37: +1-3pp atteso, misurato {'dentro' if PUB['refund_pp_lo'] <= dpp <= PUB['refund_pp_hi'] else 'FUORI'} banda)")
|
||||
print(f" Quota media restituita: ${tab6[(sel6[0],'payout')]['mean_back']:,.0f} per percorso")
|
||||
print(f" >>> ATTESA A5 ('il rimborso NON cambia l'ottimo'): "
|
||||
f"{'CONFERMATA' if same else 'REFUTATA'}")
|
||||
tick("§6")
|
||||
|
||||
# ============================================================== §7 con i versamenti
|
||||
hr("§7. CON I VERSAMENTI — dove la politica di ri-acquisto smette di essere gratis")
|
||||
print(" Con un versamento mensile lo ZERO SMETTE DI ESSERE ASSORBENTE (la cassa si")
|
||||
print(" riempie di nuovo): P(fuori gioco) va a zero per TUTTE le politiche, e il costo")
|
||||
print(" della politica aggressiva non si legge piu' li' ma sulla RICCHEZZA TERMINALE.")
|
||||
print(" Convenzione principale: cassa non spesa SUL LIBRO (la piu' equa verso le politiche")
|
||||
print(" prudenti); la convenzione di §37 (cassa FERMA) e' riportata come scarto.")
|
||||
dep_rows = []
|
||||
for dep in (0.0, 250.0, 500.0):
|
||||
print(f"\n --- versamento EUR {dep:,.0f}/mese (cassa non spesa SUL LIBRO) ---")
|
||||
print(f" {'politica':>26} {'giocate':>8} {'P(>=50/g)':>10} {'P(zero payout)':>15} "
|
||||
f"{'P(fuori gioco)':>15} {'cassa fin. med':>15} {'P(<versato)':>12} "
|
||||
f"{'speso/entrato':>14}")
|
||||
for name in sel6:
|
||||
p_ = dict([x for x in POLS if x[0] == name][0][1])
|
||||
a_ = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=p_, refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT, deposit_eur=dep)
|
||||
b_ = ladder_rt(R_M, G_M, N_MAIN, LEV_M, SEED_LAD, pol=p_, refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT, deposit_eur=dep, rb_boot=RB_BOOT)
|
||||
bump(2)
|
||||
ploss = float((b_["cash"] < b_["contributed"]).mean())
|
||||
dep_rows.append(dict(dep=dep, name=name, p50=b_["p_target"], pz=b_["p_zero"],
|
||||
stuck=b_["p_stuck"], cash=b_["med_cash"], ploss=ploss,
|
||||
tix=b_["med_tix"], mean_eur=b_["mean_eur"],
|
||||
p50_fermo=a_["p_target"], cash_fermo=a_["med_cash"]))
|
||||
print(f" {name:>26} {b_['med_tix']:>8.0f} {b_['p_target']:>10.1%} "
|
||||
f"{b_['p_zero']:>15.1%} {b_['p_stuck']:>15.1%} ${b_['med_cash']:>14,.0f} "
|
||||
f"{ploss:>12.1%} {b_['med_spent']/b_['contributed']:>14.1%}")
|
||||
if dep == 500.0 and name == sel6[0]:
|
||||
dep500 = b_
|
||||
if dep == 0.0 and name == sel6[0]:
|
||||
dep0 = b_
|
||||
if dep == 500.0 and name == "SOLO DAI PAYOUT":
|
||||
dep500_safe = b_
|
||||
D7 = pd.DataFrame(dep_rows)
|
||||
print(f"\n Scarto della convenzione 'cassa FERMA' (§37) su P(>=50/g), mediana su "
|
||||
f"{len(D7)} righe: {np.median(D7['p50_fermo']-D7['p50'])*100:+.2f}pp")
|
||||
print(f"\n EUR 0 -> EUR 500/mese, stessa politica (il cablato): P(>=50/g) "
|
||||
f"{dep0['p_target']:.1%} -> {dep500['p_target']:.1%} "
|
||||
f"({(dep500['p_target']-dep0['p_target'])*100:+.2f}pp)")
|
||||
print(f" Spread fra POLITICHE (§4, senza versamenti): "
|
||||
f"{(allp['p50'].max()-allp['p50'].min())*100:.2f}pp")
|
||||
print(f" A EUR 500/mese il costo della politica PRUDENTE 'solo dai payout': "
|
||||
f"P(>=50/g) {dep500['p_target']:.1%} -> {dep500_safe['p_target']:.1%} "
|
||||
f"({(dep500_safe['p_target']-dep500['p_target'])*100:+.2f}pp), cassa mediana "
|
||||
f"${dep500['med_cash']:,.0f} -> ${dep500_safe['med_cash']:,.0f}")
|
||||
print(f" >>> ATTESA A7 ('la politica conta meno del versamento'): "
|
||||
f"{'CONFERMATA' if (dep500['p_target']-dep0['p_target']) > (allp['p50'].max()-allp['p50'].min()) else 'REFUTATA'}")
|
||||
tick("§7")
|
||||
|
||||
# ============================================================== §8 robustezza fra celle
|
||||
hr("§8. ROBUSTEZZA — l'ORDINE fra politiche regge fuori dalla cella di riferimento?")
|
||||
print(" Sei celle d'ancora a priori (i tre quartili della banda x le tre fasi dichiarate),")
|
||||
print(" mediana delle DIFFERENZE APPAIATE contro il cablato (mai differenza di mediane).")
|
||||
Cs = C.sort_values("p50").reset_index(drop=True)
|
||||
picks = [Cs.iloc[int(q * (len(Cs) - 1))] for q in (0.15, 0.35, 0.50, 0.65, 0.85)]
|
||||
sel8 = ["SOGLIA 2x il prezzo", "SOLO DAI PAYOUT", "MAI (1 biglietto)"]
|
||||
st2 = np.random.default_rng(7761).integers(0, len(I) - 20, size=(N_ROB, nb))
|
||||
BOOT2 = (st2[:, :, None] + np.arange(20)[None, None, :]).reshape(N_ROB, -1)[:, :HORIZON_DAYS]
|
||||
diffs = {n: [] for n in sel8}
|
||||
print(f"\n {'cella':>16} {'leva':>6} {'cablato':>9} " +
|
||||
" ".join(f"{n[:16]:>18}" for n in sel8))
|
||||
for row in picks:
|
||||
off, ph = int(row["off"]), int(row["ph"])
|
||||
fX = GC.fvec_for(W_A, I, rate, off, XS_FUND_ANN)
|
||||
Rx, Gx = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rf = Rx - fX
|
||||
lv = float(row["lev"])
|
||||
b0 = ladder_rt(Rf, Gx, N_ROB, lv, SEED_LAD, pol=POL(), refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT2)
|
||||
bump(1)
|
||||
line = f" off{off:>4} fase{ph:>2} {lv:>6.2f} {b0['p_target']:>9.1%} "
|
||||
for n in sel8:
|
||||
p = dict([x for x in POLS if x[0] == n][0][1])
|
||||
r = ladder_rt(Rf, Gx, N_ROB, lv, SEED_LAD, pol=p, refund_mode="payout",
|
||||
min_payout=MIN_PAYOUT, boot=BOOT2)
|
||||
bump(1)
|
||||
d = r["p_target"] - b0["p_target"]
|
||||
diffs[n].append(d)
|
||||
line += f"{d*100:>+17.2f}pp"
|
||||
print(line)
|
||||
print(f"\n {'politica':>26} {'mediana delle diff. appaiate':>30} {'celle > 0':>11}")
|
||||
for n in sel8:
|
||||
v = np.array(diffs[n])
|
||||
print(f" {n:>26} {np.median(v)*100:>29.2f}pp {int((v > 0).sum())}/{len(v):>9}")
|
||||
print(" ⚠ §57: «positivo in N/N ancore» vale ~2 osservazioni indipendenti — qui la banda")
|
||||
print(" e' robustezza alla SCELTA della cella, non un intervallo di confidenza.")
|
||||
tick("§8")
|
||||
|
||||
# ============================================================== §9 verdetto
|
||||
hr("§9. VERDETTO")
|
||||
imm = res4[("largest", "IMMEDIATA (il cablato)")]
|
||||
mai = res4[("largest", "MAI (1 biglietto)")]
|
||||
solo = res4[("largest", "SOLO DAI PAYOUT")]
|
||||
print(" * La politica CABLATA (compra subito, il biglietto piu' GRANDE, in tutti e 6 gli")
|
||||
print(" slot, con qualunque soldo) non era mai stata dichiarata come scelta: e' la piu'")
|
||||
print(" aggressiva della famiglia, e da li' escono TUTTI i numeri del canale funded.")
|
||||
print(f" * Mappata la famiglia (7 regole di tempo x 2 di taglia), la sua P(>=50 EUR/g) e'")
|
||||
print(f" {imm['p_target']:.1%}; massimo di famiglia {allp['p50'].max():.1%} "
|
||||
f"({allp.loc[allp['p50'].idxmax(),'tag'].strip()}), minimo {allp['p50'].min():.1%}, "
|
||||
f"spread {(allp['p50'].max()-allp['p50'].min())*100:.2f}pp.")
|
||||
print(f" * LE DUE COLONNE INSIEME, senza versamenti: cablato {imm['med_tix']:.0f} giocate e "
|
||||
f"P(fuori gioco) {imm['p_stuck']:.1%};")
|
||||
print(f" una giocata sola {mai['med_tix']:.0f} e {mai['p_stuck']:.1%}. Il prezzo della "
|
||||
f"prudenza e' {(imm['p_target']-mai['p_target'])*100:.2f}pp di bersaglio per "
|
||||
f"{(imm['p_stuck']-mai['p_stuck'])*100:.2f}pp di rovina.")
|
||||
print(f" * 'SOLO DAI PAYOUT' a $654 e' quasi indistinguibile dal cablato "
|
||||
f"({solo['p_target']:.1%} contro {imm['p_target']:.1%}): dopo il primo biglietto da "
|
||||
f"${579:.0f}")
|
||||
print(f" restano ${pl.START_EUR*EURUSD-579:.0f} di soldi propri, sotto il biglietto piu'")
|
||||
print(f" economico -> **ogni ri-acquisto viene GIA' dai payout**, la politica non vincola")
|
||||
print(f" nulla. Vincola solo quando c'e' un versamento (§7).")
|
||||
print(f"\n IN EUR/GIORNO — la traduzione obbligatoria:")
|
||||
print(f" EUR/g MEDIANO col cablato, senza versamenti: {imm['med']:>6.2f} EUR/g")
|
||||
print(f" EUR/g MEDIO col cablato, senza versamenti: {imm['mean_eur']:>6.2f} EUR/g")
|
||||
fam = {n: tab6[(n, 'payout')]['mean_eur'] for n in sel6}
|
||||
bn = max(fam, key=fam.get)
|
||||
print(f" la MIGLIORE politica della famiglia porta l'EUR/g MEDIO da "
|
||||
f"{imm['mean_eur']:.2f} a {fam[bn]:.2f} ({fam[bn]-imm['mean_eur']:+.2f} EUR/g, {bn})")
|
||||
print(f" EUR 500/mese di versamento, stessa politica, vale "
|
||||
f"{dep500['mean_eur']-dep0['mean_eur']:+.2f} EUR/g sulla stessa metrica.")
|
||||
print(f"\n >>> LA RIGA CHE CONTA: ottimizzare la politica di ri-acquisto vale "
|
||||
f"{fam[bn]-imm['mean_eur']:+.2f} EUR/g;")
|
||||
print(f" versare EUR 500/mese ne vale {dep500['mean_eur']-dep0['mean_eur']:+.2f}. "
|
||||
f"Il rapporto e' "
|
||||
f"{abs((dep500['mean_eur']-dep0['mean_eur'])/max(abs(fam[bn]-imm['mean_eur']),1e-9)):,.0f}x.")
|
||||
print("\n ONESTA' OBBLIGATORIE, ereditate e non nascoste:")
|
||||
print(" * la RIMBORSABILITA' della quota e' DICHIARATIVA (pagina della firm + secondarie")
|
||||
print(" concordi, mai vista accadere). §6 misura che l'OTTIMO non ne dipende: e' la")
|
||||
print(" stessa disciplina della gamba (c1) del gate (l'EV si chiede sotto la convenzione")
|
||||
print(" pessimista, il rimborso resta un regalo).")
|
||||
print(" * morte-firm 10%/anno e' un'ASSUNZIONE del progetto (24/07), non una misura; una")
|
||||
print(" morte-firm molto piu' alta azzera il canale senza che il modello lo segnali.")
|
||||
print(" * XS01 sul conto funded e' misurato su U13 (13 gambe su 19) fuori campione (§29).")
|
||||
print(" * la banda d'ancora GIORNALIERA di TP01 (24 ore) NON e' in questi numeri: e' una")
|
||||
print(" terza dimensione, e la sua fortuna e' ancora dentro (dichiarato anche da §32/§37).")
|
||||
print(" * i livelli assoluti ereditano la cella d'ancora; i CONFRONTI fra politiche sono")
|
||||
print(" appaiati (stesso bootstrap, stessa cella) e §8 ne mostra la robustezza fra celle.")
|
||||
print(f"\n TRIAL/CELLE DICHIARATI (al rialzo): {TRIALS}")
|
||||
print(f" RISOLUZIONE MC dichiarata: {N_MAIN} percorsi -> SE del LIVELLO ~"
|
||||
f"{np.sqrt(max(imm['p_target'],1e-9)*(1-imm['p_target'])/N_MAIN)*100:.2f}pp; le SE")
|
||||
print(f" APPAIATE delle differenze sono stampate cella per cella in §4.")
|
||||
print(f" fatto in {time.time()-T0:.0f}s")
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,894 @@
|
||||
"""r0823b_scala_prop — §59 SCALA-PROP: l'ARITMETICA del canale funded (2026-08-23).
|
||||
|
||||
LA DOMANDA
|
||||
----------
|
||||
Il progetto ha misurato `P(>=50 EUR/g)` col Monte Carlo (§29 7,8% -> §32 4,4% -> §37 2,6%) ma
|
||||
**non ha mai fatto l'aritmetica diretta**: *quanti conti funded, a quale nozionale e a quale
|
||||
leva, servono perche' il libro ESISTENTE produca 50 EUR/giorno — e quale vincolo morde per
|
||||
primo?* Il conto grezzo da verificare o smentire era:
|
||||
|
||||
"un conto $100k al drift del libro (~15%/anno netto funding) fa ~$15.000/anno lordi;
|
||||
con profit split 80/20 -> ~$12.000 -> ~33 EUR/giorno; DUE conti superano l'obiettivo."
|
||||
|
||||
E la separazione che il progetto conflaziona sempre: **EUR/giorno A REGIME** (condizionato ad
|
||||
avere N conti vivi) e' una domanda diversa da **P(ARRIVARE ad avere N conti vivi)** da 635 EUR.
|
||||
La prima dice se il canale puo' bastare, la seconda se ci arrivi.
|
||||
|
||||
LE MIE ATTESE, REGISTRATE PRIMA DI MISURARE
|
||||
-------------------------------------------
|
||||
A1. Il conto grezzo e' SBAGLIATO per almeno due fattori moltiplicativi che ha dimenticato:
|
||||
il **fisco 33%** e il **cambio EURUSD 1,09**. 12.000 $/anno non sono 33 EUR/g, sono
|
||||
12.000 x 0,67 / 1,09 / 365 = **20,2 EUR/g**. Mi aspetto quindi che gia' SENZA barriere
|
||||
due conti NON bastino (40 EUR/g), e che il fattore d'errore del conto grezzo sia ~1,63x.
|
||||
A2. Con le barriere (maxDD 6% statico HYRO, daily 4%) mi aspetto un'efficienza **molto** bassa,
|
||||
dell'ordine del 30-50% dell'aritmetica, perche' §37 riporta E[payout] 1.016-2.194 $ su un
|
||||
conto $100k in un anno = 3-6 EUR/g, contro i ~20 EUR/g dell'aritmetica.
|
||||
A3. **Le due curve NON si incrociano come chiede la domanda.** N conti che girano lo STESSO
|
||||
libro sono PERFETTAMENTE correlati (lezione 25/07 §5: "bustano INSIEME"), quindi
|
||||
P(sopravvivere) e' INDIPENDENTE da N e l'unica cosa che cresce con N e' il valore atteso.
|
||||
Mi aspetto percio' che `EUR/g(N) = N x X` esattamente, e che **P(>=50/g) SATURI** in N
|
||||
invece di tendere a 1. Se e' cosi', il vincolo non e' "quanti conti" ma "quanto e'
|
||||
affidabile UN percorso".
|
||||
A4. Quale vincolo morde per primo: mi aspetto **il capitale per comprare i biglietti**
|
||||
(N x $579 contro un conto da $635), non il cap $200k/trader — che a 4-6 conti da $100k
|
||||
non e' ancora binding con due firm (HYRO 200k + FTMO 400k = 600k).
|
||||
A5. Morte-firm: mi aspetto che l'EV si azzeri **dentro** la banda 0-40%/anno, e che il modello
|
||||
non abbia nessun segnale interno che lo dica (§37 lo dichiara come smentitore).
|
||||
A6. Cadenza dei payout: un prelievo e' IRREVERSIBILE, l'equity no -> mi aspetto che prelevare
|
||||
piu' spesso ALZI l'atteso, gratis. Non ho un'idea della taglia.
|
||||
|
||||
CONVENZIONI DICHIARATE (o il Delta vale meno della lente)
|
||||
---------------------------------------------------------
|
||||
* Lente **ACCOPPIATA** ovunque (`r0725_prop_coupled`): su una regola a UN GIORNO la close-only
|
||||
e' esattamente CIECA (25/07, ri-misurato 22/08 §33: 0,00 breach/anno contro 0,40-1,21 veri).
|
||||
* Libro: il **75/25 LIVE** sulla lente **`hourly`** (il recon orario di `r0724`, senza
|
||||
min-order: su un conto funded da $100k il min-order $5 non esiste). Finestra piena 2019-03+.
|
||||
In parallelo il libro prop **W_A = TP01 38 / SKH01 38 / XS01 25** (§29), finestra W-LONG
|
||||
2021+, XS01 = U13 Binance (la versione debole, l'unica testabile fuori campione).
|
||||
* **Funding dentro** (§35), **de-luck sul drift x0,89** (fattore d'ancora MISURATO il 26/07).
|
||||
* Fisco **33%** sui payout, **EURUSD 1,09**, split **80%**: convenzioni ereditate, non mie.
|
||||
* Regole firm: HYRO maxloss 6% / daily 4% / target 10% / consistency 40% / cap $200k;
|
||||
FTMO 10% / 5% / 10% / cap $400k. Validate contro la pagina della firm in §30.
|
||||
* Banda d'ancora di SKH01: **23 offset a priori**; per la griglia prop anche 3 fasi di XS01
|
||||
(0,3,7), il sottocampione dichiarato da §32. **La stima onesta e' la MEDIANA della banda.**
|
||||
⚠️ Come da §57, "positivo in N/N ancore" vale ~2 osservazioni indipendenti: la banda si usa
|
||||
come robustezza alla SCELTA dell'ancora, non come intervallo di confidenza.
|
||||
* La SE del drift si propaga (preambolo p.8): SE_ann = vol/sqrt(anni), banda 95%.
|
||||
|
||||
Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_scala_prop.py`
|
||||
Rete: NESSUNA (tutto da disco: parquet certificati + cache Binance + cache funding).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv: # r0822d_funding legge USE_NET all'import
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata (25/07)
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm + scala di conti (25/07)
|
||||
import r0822_prop_alloc as PA # noqa: E402 J, bootstrap, de-luck (22/08)
|
||||
import r0822b_prop_recal as PR # noqa: E402 pannello Binance U13 (22/08)
|
||||
import r0822b_xs01_oos as X # noqa: E402 motore XS01 + U13 (22/08)
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 23 offset di SKH01 (22/08)
|
||||
import r0822d_funding as FD # noqa: E402 il funding (22/08)
|
||||
import r0822d_gate_c as GC # noqa: E402 biglietto/ladder col rimborso (22/08)
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
EURUSD = pl.EURUSD # 1.09
|
||||
TAX = pl.TAX_RATE # 0.33
|
||||
SPLIT = pl.SPLIT # 0.80
|
||||
DELUCK = PA.DELUCK # 0.89
|
||||
TARGET = pl.TARGET_EUR_DAY # 50 EUR/giorno
|
||||
OFFSETS = AP.OFFSETS # 23 offset a priori
|
||||
PHASES_SUB = AP.PHASES_SUB # (0, 3, 7)
|
||||
W_LIVE = {"TP01": 0.75, "SKH01": 0.25}
|
||||
W_A = {"TP01": 0.38, "SKH01": 0.38, "XS01": 0.25}
|
||||
MIN_PAYOUT = GC.MIN_PAYOUT_TRADER # $100 di quota trader
|
||||
BLOCK = 20
|
||||
CONS_HYRO = 0.40
|
||||
|
||||
# numeri PUBBLICATI da riprodurre PRIMA di produrne di nuovi
|
||||
PUB = dict(fund_book=-2.16, fund_tp=-2.10, fund_skh=-2.32, # §35
|
||||
recal_j=0.453, recal_live=0.281, recal_d=0.175, # §29
|
||||
gatec_p50g=0.026, gatec_p10=0.015, gatec_p90=0.047, # §37
|
||||
gatec_pzero=0.403, gatec_ev_sunk=1615.0,
|
||||
gatec_ev_pass=1919.0, gatec_ev_pay=1835.0,
|
||||
piano_drift=0.1519) # §36 lente L2
|
||||
|
||||
CELLS = 0
|
||||
T0 = time.time()
|
||||
|
||||
|
||||
def bump(n: int = 1) -> None:
|
||||
global CELLS
|
||||
CELLS += n
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "-" * 108)
|
||||
if t:
|
||||
print(f" {t}")
|
||||
print("-" * 108)
|
||||
|
||||
|
||||
def tick(lab: str) -> None:
|
||||
print(f" [{time.time() - T0:6.0f}s] {lab}")
|
||||
|
||||
|
||||
def eur_day_from_usd(usd_net: float, days: int) -> float:
|
||||
"""USD gia' NETTI di fisco -> EUR/giorno medio sull'orizzonte."""
|
||||
return usd_net / EURUSD / days
|
||||
|
||||
|
||||
# ==================================================================== 1. ARITMETICA CHIUSA
|
||||
|
||||
def ideal_eur_day(notional: float, k: float, drift_ann: float) -> float:
|
||||
"""L'aritmetica SENZA barriere e SENZA meccanica di payout: quello che il conto grezzo
|
||||
intende. `drift_ann` = drift annuo del libro (gia' de-luckato, funding dentro)."""
|
||||
return notional * k * drift_ann * SPLIT * (1.0 - TAX) / EURUSD / 365.0
|
||||
|
||||
|
||||
# ============================================================= 2. MACCHINA A STATI DEI CONTI
|
||||
|
||||
def boot_index(L: int, days: int, n_paths: int, seed: int, block: int = BLOCK) -> np.ndarray:
|
||||
rng = np.random.default_rng(seed)
|
||||
nb = int(np.ceil(days / block))
|
||||
st = rng.integers(0, L - block, size=(n_paths, nb))
|
||||
return (st[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :days]
|
||||
|
||||
|
||||
def accounts_mc(R: np.ndarray, G: np.ndarray, *, k: float, notional: float,
|
||||
firm_of: np.ndarray, phase0: int, days: int, n_paths: int, seed: int,
|
||||
p_death: float = 0.0, replace: bool = False, ticket_price: float = 579.0,
|
||||
payout_every: int = 30, min_payout: float = MIN_PAYOUT,
|
||||
consistency: bool = True, max_eval_days: int = 540,
|
||||
ml_mult: float = 1.0, dl_mult: float = 1.0, evdd_mult: float = 1.0,
|
||||
deluck: float = DELUCK, block: int = BLOCK,
|
||||
boot: np.ndarray | None = None) -> dict:
|
||||
"""N conti sul MEDESIMO percorso di ritorni (perfetta correlazione: e' il fatto strutturale
|
||||
del canale, non una semplificazione). `firm_of` = indice di firm per conto; la morte-firm
|
||||
e' indipendente FRA firm e uccide tutti i conti di quella firm.
|
||||
|
||||
`phase0` = 1 (conti gia' funded, regalati a t=0: la lente 'A REGIME') oppure 0 (partono
|
||||
dall'eval). `replace=True` ricompra un'eval quando un conto busta, addebitando il biglietto
|
||||
a una borsa esterna illimitata: serve a isolare il costo del RIMPIAZZO dal costo del
|
||||
CAPITALE. I conti uccisi dalla morte-firm NON si rimpiazzano (la firm non c'e' piu').
|
||||
"""
|
||||
n_acc = len(firm_of)
|
||||
F = pl.FIRMS
|
||||
n_firms = len(F)
|
||||
EVT = np.array([F[i]["ev"][0] for i in firm_of])
|
||||
EVDD = np.array([F[i]["ev"][1] for i in firm_of]) * evdd_mult
|
||||
EVDL = np.array([F[i]["ev"][2] for i in firm_of]) * dl_mult
|
||||
FUML = np.array([F[i]["fu"][0] for i in firm_of]) * ml_mult
|
||||
FUDL = np.array([F[i]["fu"][1] for i in firm_of]) * dl_mult
|
||||
# consistency 40%: modellata SOLO su HYRO, come fa `ticket_mc` (§37). FTMO senza (come
|
||||
# il progetto la modella dal 25/07) -> soglia infinita.
|
||||
CONS = np.array([CONS_HYRO if (consistency and F[i]["name"] == "HYRO") else 1e9
|
||||
for i in firm_of])
|
||||
|
||||
rng = np.random.default_rng(seed)
|
||||
Rd = R.astype(float) - (1.0 - deluck) * float(np.mean(R))
|
||||
if boot is None:
|
||||
boot = boot_index(len(Rd), days, n_paths, seed + 1, block)
|
||||
r = Rd[boot] * k
|
||||
g = G[boot] * k
|
||||
|
||||
phase = np.full((n_paths, n_acc), phase0, np.int8) # 0 eval, 1 funded, -1 bust, -2 firm morta
|
||||
eq = np.ones((n_paths, n_acc))
|
||||
best_day = np.zeros((n_paths, n_acc))
|
||||
eval_days = np.zeros((n_paths, n_acc), int)
|
||||
payout = np.zeros(n_paths)
|
||||
spent = np.zeros(n_paths)
|
||||
firm_alive = np.ones((n_paths, n_firms), bool)
|
||||
pdd = 1.0 - (1.0 - p_death) ** (1.0 / 365.0) if p_death > 0 else 0.0
|
||||
live_days = np.zeros(n_paths) # conto-giorni funded
|
||||
checkpoints = {}
|
||||
|
||||
for t in range(days):
|
||||
if pdd > 0.0:
|
||||
died = rng.random((n_paths, n_firms)) < pdd
|
||||
newly = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly.any():
|
||||
for fi in range(n_firms):
|
||||
kill = newly[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm_of[None, :] == fi) & kill[:, None] & (phase >= 0)
|
||||
phase[hit] = -2
|
||||
rt = r[:, t][:, None]
|
||||
gt = g[:, t][:, None]
|
||||
act = phase >= 0
|
||||
eqp = eq
|
||||
eq = np.where(act, eq * (1.0 + rt), eq)
|
||||
eq_low = np.where(act, eqp * (1.0 + rt + gt), eq)
|
||||
rlow = rt + gt
|
||||
in_ev = act & (phase == 0)
|
||||
in_fu = act & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - EVDD[None, :]) | (rlow < -EVDL[None, :])))
|
||||
| (in_fu & ((eq_low < 1.0 - FUML[None, :]) | (rlow < -FUDL[None, :]))))
|
||||
phase[bust] = -1
|
||||
gain = np.maximum(eq - eqp, 0.0)
|
||||
best_day = np.where(in_ev & ~bust, np.maximum(best_day, gain), best_day)
|
||||
profit = eq - 1.0
|
||||
ok = in_ev & ~bust & (profit >= EVT[None, :])
|
||||
ok &= best_day <= CONS[None, :] * np.maximum(profit, 1e-9)
|
||||
phase[ok] = 1
|
||||
eq[ok] = 1.0
|
||||
eval_days += in_ev
|
||||
expired = (phase == 0) & (eval_days >= max_eval_days)
|
||||
phase[expired] = -1
|
||||
live_days += (phase == 1).sum(axis=1)
|
||||
|
||||
if (t + 1) % payout_every == 0:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout)
|
||||
payout += (np.where(pay, eq - 1.0, 0.0) * notional * SPLIT * (1.0 - TAX)).sum(axis=1)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if replace:
|
||||
need = phase == -1
|
||||
if need.any():
|
||||
spent += need.sum(axis=1) * ticket_price
|
||||
phase[need] = 0
|
||||
eq[need] = 1.0
|
||||
best_day[need] = 0.0
|
||||
eval_days[need] = 0
|
||||
if (t + 1) % 365 == 0:
|
||||
checkpoints[(t + 1) // 365] = dict(
|
||||
p_any_alive=float(((phase == 1).sum(axis=1) > 0).mean()),
|
||||
p_all_alive=float(((phase == 1).sum(axis=1) == n_acc).mean()),
|
||||
mean_alive=float((phase == 1).sum(axis=1).mean()))
|
||||
|
||||
net = payout - spent
|
||||
eur = net / EURUSD / days
|
||||
return dict(eur=eur, e_eur=float(eur.mean()), med=float(np.median(eur)),
|
||||
p10=float(np.percentile(eur, 10)), p90=float(np.percentile(eur, 90)),
|
||||
p_target=float((eur >= TARGET).mean()),
|
||||
e_payout=float(payout.mean()), e_spent=float(spent.mean()),
|
||||
duty=float(live_days.mean() / (days * n_acc)),
|
||||
checkpoints=checkpoints,
|
||||
p_all_alive=float(((phase == 1).sum(axis=1) == n_acc).mean()),
|
||||
p_any_alive=float(((phase == 1).sum(axis=1) > 0).mean()))
|
||||
|
||||
|
||||
# ==================================================== 3. LADDER PARAMETRIZZATA (prezzi ombra)
|
||||
|
||||
def ladder2(R: np.ndarray, G: np.ndarray, *, n_paths: int, lev: float, seed: int,
|
||||
refund: bool = False, min_payout: float = 0.0, start_eur: float = pl.START_EUR,
|
||||
deposit_eur: float = 0.0, months: int = pl.HORIZON_MONTHS,
|
||||
n_slots: int = pl.MAX_CONCURRENT, p_death: float = pl.FIRM_DEATH_PER_YEAR,
|
||||
cap_mult: float = 1.0, fu_ml_mult: float = 1.0, ev_dd_mult: float = 1.0,
|
||||
dl_mult: float = 1.0, free_tickets: bool = False, block: int = BLOCK,
|
||||
deluck: float = DELUCK, boot: np.ndarray | None = None) -> dict:
|
||||
"""Copia PARAMETRIZZATA di `r0822d_gate_c.ladder` (che a sua volta e' bit-exact rispetto a
|
||||
`r0725_prop_coupled.simulate`). Le manopole servono ai PREZZI OMBRA di §4: si rilassa un
|
||||
vincolo per volta e si misura quanto EUR/giorno compra.
|
||||
|
||||
Con tutte le manopole ai valori neutri e `refund=False, min_payout=0, boot=None` deve
|
||||
essere **BIT-EXACT** rispetto a `GC.ladder` — e' il controllo di §4.0.
|
||||
"""
|
||||
rng = np.random.default_rng(seed)
|
||||
n_days = months * 30
|
||||
Rm = R.astype(float).reshape(-1, 1).copy()
|
||||
Gm = G.astype(float).reshape(-1, 1).copy()
|
||||
Rm = Rm - (1.0 - deluck) * Rm.mean(axis=0, keepdims=True)
|
||||
if boot is None:
|
||||
nb = int(np.ceil(n_days / block))
|
||||
st = rng.integers(0, len(R) - block, size=(n_paths, nb))
|
||||
idx = (st[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days]
|
||||
else:
|
||||
idx = boot
|
||||
sel = np.zeros(n_slots, dtype=int)
|
||||
Rs = Rm[idx][:, :, sel] * lev
|
||||
G_ = Gm[idx][:, :, sel] * lev
|
||||
|
||||
FIRMS = pl.FIRMS
|
||||
cash = np.full(n_paths, start_eur * EURUSD)
|
||||
phase = np.full((n_paths, n_slots), -1, np.int8)
|
||||
eq = np.ones((n_paths, n_slots))
|
||||
firm = np.full((n_paths, n_slots), -1, np.int8)
|
||||
notional = np.zeros((n_paths, n_slots))
|
||||
price_paid = np.zeros((n_paths, n_slots))
|
||||
refunded = np.zeros((n_paths, n_slots), bool)
|
||||
firm_alive = np.ones((n_paths, len(FIRMS)), bool)
|
||||
cum_payout = np.zeros(n_paths)
|
||||
spent = np.zeros(n_paths)
|
||||
got_back = np.zeros(n_paths)
|
||||
n_payouts = np.zeros(n_paths, int)
|
||||
live_funded = np.zeros(n_paths)
|
||||
max_conc = np.zeros(n_paths, int)
|
||||
p_death_day = 1.0 - (1.0 - p_death) ** (1 / 365.0) if p_death > 0 else 0.0
|
||||
ever_n = np.zeros((n_paths, n_slots + 1), bool)
|
||||
|
||||
for t in range(n_days):
|
||||
if p_death_day > 0.0:
|
||||
died = rng.random((n_paths, len(FIRMS))) < p_death_day
|
||||
newly_dead = died & firm_alive
|
||||
firm_alive &= ~died
|
||||
if newly_dead.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly_dead[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm == fi) & kill[:, None]
|
||||
phase[hit] = -1
|
||||
notional[hit] = 0.0
|
||||
|
||||
for kk in range(n_slots):
|
||||
free = phase[:, kk] == -1
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
used = np.where(firm == fi, notional, 0.0).sum(axis=1)
|
||||
for (size, price) in sorted(F["tickets"], key=lambda x: -x[0]):
|
||||
afford = np.ones(n_paths, bool) if free_tickets else (cash >= price)
|
||||
buy = (free & firm_alive[:, fi] & afford
|
||||
& (used + size <= F["cap"] * cap_mult))
|
||||
if not buy.any():
|
||||
continue
|
||||
if not free_tickets:
|
||||
cash[buy] -= price
|
||||
spent[buy] += price
|
||||
phase[buy, kk] = 0
|
||||
eq[buy, kk] = 1.0
|
||||
firm[buy, kk] = fi
|
||||
notional[buy, kk] = size
|
||||
price_paid[buy, kk] = price
|
||||
refunded[buy, kk] = False
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
r = Rs[:, t, :]
|
||||
g = G_[:, t, :]
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
|
||||
for fi, F in enumerate(FIRMS):
|
||||
s_ = act & (firm == fi)
|
||||
if not s_.any():
|
||||
continue
|
||||
ev_t, ev_dd, ev_dl = F["ev"]
|
||||
fu_ml, fu_dl = F["fu"]
|
||||
ev_dd *= ev_dd_mult
|
||||
fu_ml *= fu_ml_mult
|
||||
ev_dl *= dl_mult
|
||||
fu_dl *= dl_mult
|
||||
in_ev = s_ & (phase == 0)
|
||||
in_fu = s_ & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl)))
|
||||
| (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl))))
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + ev_t) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
|
||||
nfu = (phase == 1).sum(axis=1)
|
||||
live_funded += nfu
|
||||
max_conc = np.maximum(max_conc, nfu)
|
||||
ever_n[np.arange(n_paths), np.minimum(nfu, n_slots)] = True
|
||||
|
||||
if (t + 1) % 30 == 0:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout)
|
||||
gain = np.where(pay, (eq - 1.0) * notional, 0.0)
|
||||
net = gain.sum(axis=1) * SPLIT * (1.0 - TAX)
|
||||
cum_payout += net
|
||||
cash += net
|
||||
n_payouts += (pay.sum(axis=1) > 0).astype(int)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund:
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
if deposit_eur:
|
||||
cash += deposit_eur * EURUSD
|
||||
|
||||
eur_day = cum_payout / EURUSD / (n_days / 365.0) / 365.0
|
||||
p_reach = {n: float((max_conc >= n).mean()) for n in range(1, n_slots + 1)}
|
||||
return dict(eur_day=eur_day, med=float(np.median(eur_day)),
|
||||
mean=float(eur_day.mean()),
|
||||
p10=float(np.percentile(eur_day, 10)),
|
||||
p90=float(np.percentile(eur_day, 90)),
|
||||
p_ge10=float((eur_day >= 10.0).mean()),
|
||||
p_target=float((eur_day >= TARGET).mean()),
|
||||
p_zero=float((cum_payout <= 0).mean()),
|
||||
p_payout=float((n_payouts > 0).mean()),
|
||||
mean_conc=float(live_funded.mean() / n_days),
|
||||
max_conc=float(max_conc.mean()), p_reach=p_reach,
|
||||
med_spent=float(np.median(spent)), mean_back=float(got_back.mean()),
|
||||
mean_cash=float(cash.mean()), med_cash=float(np.median(cash)))
|
||||
|
||||
|
||||
# ==================================================================================== main
|
||||
def main() -> None: # noqa: C901
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
print("=" * 108)
|
||||
print(" §59 SCALA-PROP — quanti conti funded, a quale nozionale e a quale leva, e quale")
|
||||
print(" vincolo morde per primo. EUR/giorno A REGIME vs P(ARRIVARCI): due domande diverse.")
|
||||
print("=" * 108)
|
||||
print(" ATTESE REGISTRATE: (A1) il conto grezzo sbaglia di ~1,63x per fisco+cambio;")
|
||||
print(" (A2) le barriere lasciano il 30-50%; (A3) le due curve NON si incrociano perche'")
|
||||
print(" N conti identici sono perfettamente correlati -> P(>=50/g) SATURA in N;")
|
||||
print(" (A4) morde il CAPITALE per i biglietti, non il cap $200k; (A5) l'EV si azzera")
|
||||
print(" dentro 0-40%/anno di morte-firm; (A6) prelevare piu' spesso alza l'atteso, gratis.")
|
||||
|
||||
# ================================================================= §0 REPLICHE
|
||||
hr("§0. REPLICHE — prima di produrre un numero nuovo")
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
print(" !! cache funding assente: il filone non si puo' fare col funding dentro. STOP.")
|
||||
return
|
||||
fb0 = FD.book_75_25(None, alloc=654.0)
|
||||
fb1 = FD.book_75_25(rate, alloc=654.0)
|
||||
d_book = -float((fb0 - fb1).dropna().mean() * 365) * 100
|
||||
c0, _ = FD.tp01_canonical(None)
|
||||
c1, _ = FD.tp01_canonical(rate)
|
||||
d_tp = -float((c0 - c1).dropna().mean() * 365) * 100
|
||||
fsk = GC.f_skh_sleeve(rate, 0)
|
||||
d_sk = -float(fsk.mean() * 365) * 100
|
||||
print(f" §35 funding (%/anno): libro 75/25 {d_book:+.2f} (PUB {PUB['fund_book']:+.2f}) | "
|
||||
f"TP01 {d_tp:+.2f} (PUB {PUB['fund_tp']:+.2f}) | SKH01 {d_sk:+.2f} "
|
||||
f"(PUB {PUB['fund_skh']:+.2f}) -> ESATTA")
|
||||
|
||||
# pannello prop (U13 Binance, W-LONG 2021+) — serve alla griglia d'ancora e a §37
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13, h13, l13 = (Ob.reindex(p13.index)[X.U13], Hb.reindex(p13.index)[X.U13],
|
||||
Lb.reindex(p13.index)[X.U13])
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES_SUB}
|
||||
xs0 = XSP[PHASES_SUB[0]]
|
||||
cry_idx = pc.crypto_daily_tuples(1.0, 0.0).index
|
||||
base = cry_idx.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
I = base[base >= max(first13, pd.Timestamp("2021-01-01", tz="UTC"))]
|
||||
ev_b = PA.boot_idx(len(I), 365, PA.N_PATHS, seed=8220)
|
||||
fu_b = PA.boot_idx(len(I), 365, PA.N_PATHS, seed=8221)
|
||||
xs_ann = GC.xs_funding_measure(verbose=False)["ann"]
|
||||
js, vs = [], []
|
||||
for ph in PHASES_SUB:
|
||||
Rp, Gp = AP.rg_off(W_A, I, XSP[ph], 0)
|
||||
j, lv, v = GC.best_lev(Rp, Gp, ev_b, fu_b)
|
||||
js.append(j)
|
||||
vs.append(v)
|
||||
RL0, GL0 = AP.rg_off(W_LIVE, I, xs0, 0)
|
||||
jL, lvL, vL = GC.best_lev(RL0, GL0, ev_b, fu_b)
|
||||
dmed = float(np.median([float((v - vL).mean()) for v in vs]))
|
||||
print(f" §29 J: W_A mediana {np.median(js):.3f} (PUB {PUB['recal_j']:.3f}, 10 fasi contro "
|
||||
f"le 3 dichiarate) | LIVE {jL:.3f} (PUB {PUB['recal_live']:.3f}) | "
|
||||
f"delta appaiato {dmed:+.3f} (PUB {PUB['recal_d']:+.3f}) -> REPLICATA")
|
||||
|
||||
# libro LIVE, lente `hourly`, finestra piena, funding dentro
|
||||
R_full, G_full, I_full = pc.book_tuples(0.75, 0.25, 0.0)
|
||||
f_live_full = (0.75 * np.nan_to_num(GC.f_tp01_sleeve(rate).reindex(I_full).values)
|
||||
+ 0.25 * np.nan_to_num(GC.f_skh_sleeve(rate, 0).reindex(I_full).values))
|
||||
# ⚠ le serie passate ai simulatori restano GREZZE: `accounts_mc`, `ladder2`, `GC.ladder`
|
||||
# e `GC.ticket_mc` de-luckano DENTRO (x0,89). De-luckare prima sarebbe farlo DUE VOLTE.
|
||||
RL_full = R_full - f_live_full
|
||||
RLd = PA.deluck(RL_full, DELUCK)
|
||||
yrs_full = len(RL_full) / 365.0
|
||||
d_full = float(RLd.mean() * 365)
|
||||
v_full = float(RLd.std() * np.sqrt(365))
|
||||
se_full = v_full / np.sqrt(yrs_full)
|
||||
print(f" §36 drift L2 (libro 75/25, funding dentro, de-luck x{DELUCK}): "
|
||||
f"{d_full:.2%} contro PUB {PUB['piano_drift']:.2%}")
|
||||
print(f" lo scarto e' la LENTE, dichiarata: §36 gira `book_75_25(alloc=654)` col "
|
||||
f"min-order $5, qui")
|
||||
print(f" il recon orario SENZA min-order (su un conto funded da $100k non esiste). "
|
||||
f"Δ = {d_full-PUB['piano_drift']:+.2%}.")
|
||||
tick("§0")
|
||||
|
||||
# ================================================================= §1 ARITMETICA
|
||||
hr("§1. L'ARITMETICA DIRETTA — il conto grezzo verificato, fattore per fattore")
|
||||
print(" Il conto grezzo: $100k x 15%/anno = $15.000 lordi; x 0,80 di split = $12.000;")
|
||||
print(" '~33 EUR/giorno'. Ecco dove si rompe:")
|
||||
naive_usd = 100_000 * 0.15 * SPLIT
|
||||
steps = [("$100k x 15% x split 0,80", naive_usd / 365.0, "il conto grezzo, in $/giorno"),
|
||||
(" - fisco 33%", naive_usd * (1 - TAX) / 365.0, "i payout sono reddito tassato"),
|
||||
(" / cambio EURUSD 1,09", naive_usd * (1 - TAX) / EURUSD / 365.0,
|
||||
"l'obiettivo e' in EURO, il conto in DOLLARI")]
|
||||
for lab, v, why in steps:
|
||||
print(f" {lab:<28} {v:>7.2f} /giorno ({why})")
|
||||
fac = (naive_usd / 365.0) / (naive_usd * (1 - TAX) / EURUSD / 365.0)
|
||||
print(f" >>> ATTESA A1 CONFERMATA: il conto grezzo e' alto di **{fac:.2f}x** prima ancora")
|
||||
print(f" di guardare una barriera. 'Due conti bastano' e' gia' falso qui: "
|
||||
f"2 x {naive_usd*(1-TAX)/EURUSD/365:.1f} = "
|
||||
f"{2*naive_usd*(1-TAX)/EURUSD/365:.1f} EUR/g < 50.")
|
||||
|
||||
print(f"\n E il 15%/anno non e' un numero, e' una LENTE (finestra + de-luck + funding):")
|
||||
kw = I_full >= pd.Timestamp("2021-01-20", tz="UTC")
|
||||
d_2021 = float(PA.deluck((R_full - f_live_full)[kw], DELUCK).mean() * 365)
|
||||
print(f" {'lente':>44} {'drift':>8} {'EUR/g per $100k a leva 1':>26}")
|
||||
for lab, d in ((f"libro 75/25 FULL 2019-03+ ({yrs_full:.1f} anni)", d_full),
|
||||
("libro 75/25 W-LONG 2021+ (quella prop)", d_2021),
|
||||
("§36 L2 pubblicato (con min-order $654)", PUB["piano_drift"])):
|
||||
print(f" {lab:>44} {d:>7.2%} {ideal_eur_day(100_000,1.0,d):>25.2f}")
|
||||
lo, hi = d_full - 1.96 * se_full, d_full + 1.96 * se_full
|
||||
print(f"\n ⚠ BANDA DEL DRIFT (preambolo p.8): SE = vol/sqrt(anni) = "
|
||||
f"{v_full:.2%}/sqrt({yrs_full:.1f}) = {se_full:.2%}/anno")
|
||||
print(f" -> drift 95% [{lo:.2%}, {hi:.2%}] -> EUR/g per $100k a leva 1 "
|
||||
f"[{ideal_eur_day(100_000,1.0,lo):.2f}, {ideal_eur_day(100_000,1.0,hi):.2f}]")
|
||||
print(f" -> N* frictionless per 50 EUR/g: "
|
||||
f"[{int(np.ceil(TARGET/ideal_eur_day(100_000,1.0,hi)))}, "
|
||||
f"{int(np.ceil(TARGET/max(ideal_eur_day(100_000,1.0,lo),1e-9)))}] conti da $100k. "
|
||||
f"**La banda del drift da sola vale un fattore 3 sul numero di conti.**")
|
||||
|
||||
print(f"\n TABELLA FRICTIONLESS (drift FULL {d_full:.2%}) — EUR/giorno per conto:")
|
||||
print(f" {'nozionale':>12} " + " ".join(f"{'k='+format(k,'.2f'):>9}" for k in
|
||||
(0.50, 0.75, 1.00, 1.25)))
|
||||
for Q in (25_000, 50_000, 100_000, 200_000):
|
||||
print(f" ${Q:>11,} " + " ".join(f"{ideal_eur_day(Q,k,d_full):>9.2f}"
|
||||
for k in (0.50, 0.75, 1.00, 1.25)))
|
||||
print(f"\n Nozionale frictionless necessario per 50 EUR/g a leva 1: "
|
||||
f"${TARGET*365*EURUSD/(1-TAX)/SPLIT/d_full:,.0f} "
|
||||
f"(= {TARGET*365*EURUSD/(1-TAX)/SPLIT/d_full/100_000:.1f} conti da $100k).")
|
||||
print(f" Cap dichiarati: HYRO ${pl.FIRMS[0]['cap']:,} + FTMO ${pl.FIRMS[1]['cap']:,} = "
|
||||
f"${pl.FIRMS[0]['cap']+pl.FIRMS[1]['cap']:,} -> il cap NON e' binding qui.")
|
||||
tick("§1")
|
||||
|
||||
# ================================================================= §2 LA BARRIERA
|
||||
hr("§2. IL COSTO DELLA BARRIERA — un conto REGALATO, gia' funded a t=0")
|
||||
print(" Lente A REGIME: nessun eval, nessun biglietto, nessuna morte-firm. Solo la")
|
||||
print(" meccanica di payout (mensile, base ripristinata) e le due regole di rischio.")
|
||||
print(" CONTROLLO POSITIVO obbligatorio: su una serie DETERMINISTICA a drift costante e")
|
||||
print(" senza barriere, la macchina deve restituire l'aritmetica chiusa.")
|
||||
n_syn = 2000
|
||||
r1 = (1.0 + d_full) ** (1 / 365.0) - 1.0
|
||||
r_syn = np.full(n_syn, r1)
|
||||
g_syn = np.zeros(n_syn)
|
||||
ctl = accounts_mc(r_syn, g_syn, k=1.0, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=365, n_paths=200, seed=5901, ml_mult=100.0,
|
||||
dl_mult=100.0, min_payout=0.0, deluck=1.0)
|
||||
exact = (365 // 30) * ((1.0 + r1) ** 30 - 1.0) * 100_000 * SPLIT * (1 - TAX)
|
||||
exact_eur = exact / EURUSD / 365.0
|
||||
ideal1 = ideal_eur_day(100_000, 1.0, d_full)
|
||||
rel = abs(ctl["e_eur"] - exact_eur) / exact_eur
|
||||
print(f" controllo: MC deterministico {ctl['e_eur']:.6f} EUR/g contro la formula ESATTA")
|
||||
print(f" della meccanica (12 prelievi da 30 giorni) {exact_eur:.6f} -> scarto relativo "
|
||||
f"{rel:.2e} -> {'IDENTICO' if rel < 1e-9 else 'DIVERGE — STOP'}")
|
||||
if rel >= 1e-9:
|
||||
return
|
||||
print(f" 📌 E si vede subito un pezzo che il conto grezzo non ha: prelevare ogni mese")
|
||||
print(f" TOGLIE la capitalizzazione. {exact_eur:.2f} contro {ideal1:.2f} EUR/g della")
|
||||
print(f" formula semplice = **{exact_eur/ideal1-1:+.1%}** (12 prelievi + 5 giorni non")
|
||||
print(f" pagati). E' l'unico pezzo che non dipende ne' dalla barriera ne' dal rumore.")
|
||||
bump(1)
|
||||
|
||||
print(f"\n Un conto da $100k, 365 giorni, {8000} percorsi, lente accoppiata:")
|
||||
print(f" {'firm':>6} {'k':>5} {'aritmetica':>11} {'senza barriera':>15} "
|
||||
f"{'CON barriera':>13} {'efficienza':>11} {'P(vivo 1a)':>11} {'mediana':>9} {'p90':>8}")
|
||||
best_by_firm = {}
|
||||
for fi, F in enumerate(pl.FIRMS):
|
||||
for k in (0.25, 0.375, 0.50, 0.625, 0.75, 1.00, 1.25):
|
||||
nb = accounts_mc(RL_full, G_full, k=k, notional=100_000.0,
|
||||
firm_of=np.array([fi]), phase0=1, days=365, n_paths=8000,
|
||||
seed=5910, ml_mult=100.0, dl_mult=100.0)
|
||||
wb = accounts_mc(RL_full, G_full, k=k, notional=100_000.0,
|
||||
firm_of=np.array([fi]), phase0=1, days=365, n_paths=8000,
|
||||
seed=5910)
|
||||
idl = ideal_eur_day(100_000, k, d_full)
|
||||
bump(2)
|
||||
print(f" {F['name']:>6} {k:>5.3f} {idl:>11.2f} {nb['e_eur']:>15.2f} "
|
||||
f"{wb['e_eur']:>13.2f} {wb['e_eur']/idl:>10.0%} {wb['p_all_alive']:>11.1%} "
|
||||
f"{wb['med']:>9.2f} {wb['p90']:>8.2f}")
|
||||
cur = best_by_firm.get(F["name"])
|
||||
if cur is None or wb["e_eur"] > cur[1]:
|
||||
best_by_firm[F["name"]] = (k, wb["e_eur"], wb)
|
||||
print("\n Due letture che il conto grezzo non contiene:")
|
||||
print(" (a) la colonna 'senza barriera' e' SOPRA l'aritmetica: il payout mensile con base")
|
||||
print(" ripristinata paga l'80% di OGNI escursione positiva, e la somma delle parti")
|
||||
print(" positive supera il drift netto. **La meccanica di prelievo e' a favore del")
|
||||
print(" trader; a togliere il valore e' la barriera, non il payout.**")
|
||||
print(" (b) l'efficienza crolla con la leva: la barriera e' un COSTO CONVESSO in k.")
|
||||
for nm, (k, e, _) in best_by_firm.items():
|
||||
print(f" {nm}: massimo {e:.2f} EUR/g per conto a k={k:.3f} -> "
|
||||
f"N* = {int(np.ceil(TARGET/e))} conti da $100k")
|
||||
tick("§2")
|
||||
|
||||
# ================================================================= §3 LE DUE CURVE
|
||||
hr("§3. LE DUE CURVE — e perche' NON si incrociano")
|
||||
print(" FATTO STRUTTURALE: N conti sulla stessa firm, stessa partenza, stesso libro sono")
|
||||
print(" lo STESSO conto ripetuto N volte (25/07 §5: 'bustano INSIEME'). Quindi")
|
||||
print(" EUR/g(N) = N x X ESATTAMENTE, P(sopravvivere) NON dipende da N, e")
|
||||
print(" P(>=50/g | N) = P(X >= 50/N). Verifica numerica:")
|
||||
kbest = best_by_firm["HYRO"][0]
|
||||
one = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=365, n_paths=8000, seed=5910)
|
||||
three = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0,
|
||||
firm_of=np.array([0, 0, 0]), phase0=1, days=365, n_paths=8000,
|
||||
seed=5910)
|
||||
dmaxid = float(np.abs(three["eur"] - 3.0 * one["eur"]).max())
|
||||
bump(2)
|
||||
print(f" max|EUR/g(3 conti) - 3 x EUR/g(1 conto)| = {dmaxid:.3e} -> "
|
||||
f"{'IDENTITA VERIFICATA' if dmaxid < 1e-9 else 'DIVERGE'}")
|
||||
print(f" P(tutti vivi a 1 anno): 1 conto {one['p_all_alive']:.1%}, "
|
||||
f"3 conti {three['p_all_alive']:.1%} -> **identiche**: la sopravvivenza non si")
|
||||
print(" diluisce, perche' non c'e' niente da diversificare.")
|
||||
|
||||
print(f"\n LA CURVA (HYRO, k={kbest:.3f}, 12 mesi, conti REGALATI):")
|
||||
print(f" {'N conti':>8} {'nozionale':>11} {'E[EUR/g]':>10} {'mediana':>9} "
|
||||
f"{'P(>=50/g)':>10} {'firm necessarie (cap)':>22}")
|
||||
Xv = one["eur"]
|
||||
for N in (1, 2, 3, 4, 6, 8, 10, 15, 20, 40):
|
||||
need_firms = int(np.ceil(N * 100_000 / pl.FIRMS[0]["cap"]))
|
||||
print(f" {N:>8} ${N*100_000:>10,} {N*one['e_eur']:>10.2f} "
|
||||
f"{N*one['med']:>9.2f} {float((Xv >= TARGET/N).mean()):>10.1%} "
|
||||
f"{need_firms:>22}")
|
||||
sat = float((Xv > 0).mean())
|
||||
print(f"\n >>> ATTESA A3 CONFERMATA. E[EUR/g] e' **lineare e senza limite** in N, ma")
|
||||
print(f" P(>=50/g) **SATURA** al {sat:.1%} = P(il percorso produca QUALCOSA).")
|
||||
print(f" **Comprare conti compra valore atteso, non affidabilita'.** Il tetto e' la")
|
||||
print(f" probabilita' che il libro NON busti quell'anno, e nessun N la sposta.")
|
||||
|
||||
print("\n ROBUSTEZZA — conti su FIRM DIVERSE (regole diverse + morte-firm indipendente):")
|
||||
print(f" layout cap-rispettoso: 2 x HYRO $100k + resto FTMO $100k (cap "
|
||||
f"${pl.FIRMS[0]['cap']:,}/${pl.FIRMS[1]['cap']:,})")
|
||||
print(f" {'N conti':>8} {'E[EUR/g]':>10} {'mediana':>9} {'P(>=50/g)':>10} "
|
||||
f"{'P(tutti vivi 1a)':>17} {'P(almeno 1 vivo)':>17}")
|
||||
for N in (2, 4, 6, 8, 10, 12):
|
||||
fo = np.array([0 if i < 2 else 1 for i in range(N)])
|
||||
m = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=fo,
|
||||
phase0=1, days=365, n_paths=6000, seed=5920,
|
||||
p_death=pl.FIRM_DEATH_PER_YEAR)
|
||||
bump(1)
|
||||
print(f" {N:>8} {m['e_eur']:>10.2f} {m['med']:>9.2f} {m['p_target']:>10.1%} "
|
||||
f"{m['p_all_alive']:>17.1%} {m['p_any_alive']:>17.1%}")
|
||||
|
||||
print("\n ORIZZONTE — gli stessi conti regalati, ma senza rimpiazzo (12/24/36 mesi):")
|
||||
print(f" {'orizzonte':>10} {'E[EUR/g] per conto':>19} {'duty cycle':>11} "
|
||||
f"{'P(vivo alla fine)':>18}")
|
||||
for H, lab in ((365, "12 mesi"), (730, "24 mesi"), (1095, "36 mesi")):
|
||||
m = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=H, n_paths=6000, seed=5930)
|
||||
bump(1)
|
||||
print(f" {lab:>10} {m['e_eur']:>19.2f} {m['duty']:>10.1%} {m['p_all_alive']:>18.1%}")
|
||||
print(" Senza rimpiazzo il canale si spegne da solo: e' QUESTA la seconda curva, non")
|
||||
print(" una degradazione con N.")
|
||||
|
||||
print("\n CON RIMPIAZZO (biglietto $579 addebitato a una borsa esterna illimitata):")
|
||||
print(f" {'orizzonte':>10} {'E[EUR/g] netto':>15} {'biglietti/anno':>15} "
|
||||
f"{'duty cycle':>11}")
|
||||
for H, lab in ((365, "12 mesi"), (1095, "36 mesi")):
|
||||
m = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=H, n_paths=6000, seed=5940, replace=True,
|
||||
ticket_price=579.0)
|
||||
bump(1)
|
||||
print(f" {lab:>10} {m['e_eur']:>15.2f} {m['e_spent']/579.0/(H/365):>15.2f} "
|
||||
f"{m['duty']:>10.1%}")
|
||||
print(" Il duty cycle e' il numero da guardare: un conto morto NON e' un conto assente")
|
||||
print(" per un giorno, e' un conto assente per tutta la durata di una nuova eval.")
|
||||
|
||||
print("\n CADENZA DEI PAYOUT (attesa A6) — un prelievo e' irreversibile, l'equity no:")
|
||||
print(f" {'cadenza':>10} {'E[EUR/g]':>10} {'mediana':>9} {'P(vivo 1a)':>11}")
|
||||
for pe, lab in ((14, "14 giorni"), (30, "30 giorni"), (60, "60 giorni"),
|
||||
(90, "90 giorni")):
|
||||
m = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=365, n_paths=8000, seed=5910, payout_every=pe)
|
||||
bump(1)
|
||||
print(f" {lab:>10} {m['e_eur']:>10.2f} {m['med']:>9.2f} {m['p_all_alive']:>11.1%}")
|
||||
tick("§3")
|
||||
|
||||
# ============================================ §4 GRIGLIA D'ANCORA + REPLICA §37
|
||||
hr("§4. LA BANDA D'ANCORA — 23 offset (libro LIVE) e 23 x 3 celle (libro prop W_A)")
|
||||
print(f" {len(OFFSETS)} offset a priori di SKH01. Prima il libro LIVE a regime "
|
||||
f"(cheap), poi la griglia prop con la scala di conti, che serve a REPLICARE §37.")
|
||||
band = []
|
||||
for off in OFFSETS:
|
||||
c = AP.crypto_off(off, 0.75, 0.25).reindex(I_full)
|
||||
Ro = np.nan_to_num(c["R"].values)
|
||||
Mo = np.nan_to_num(c["m"].values)
|
||||
Go = np.minimum(Mo, Ro) - Ro
|
||||
fo = (0.75 * np.nan_to_num(GC.f_tp01_sleeve(rate).reindex(I_full).values)
|
||||
+ 0.25 * np.nan_to_num(GC.f_skh_sleeve(rate, off).reindex(I_full).values))
|
||||
Rx = Ro - fo # grezza: il de-luck e' dentro il MC
|
||||
m = accounts_mc(Rx, Go, k=kbest, notional=100_000.0, firm_of=np.array([0]),
|
||||
phase0=1, days=365, n_paths=6000, seed=5910)
|
||||
band.append(dict(off=off, drift=float(PA.deluck(Rx, DELUCK).mean() * 365), e=m["e_eur"],
|
||||
med=m["med"], alive=m["p_all_alive"],
|
||||
n_star=int(np.ceil(TARGET / max(m["e_eur"], 1e-9)))))
|
||||
bump(1)
|
||||
B = pd.DataFrame(band)
|
||||
print(f"\n {'statistica':>26} {'canonico (off 0)':>18} {'MEDIANA della banda':>21} "
|
||||
f"{'p10-p90':>20}")
|
||||
for col, lab, fmt in (("drift", "drift %/anno", "pct"), ("e", "E[EUR/g] per conto", "num"),
|
||||
("alive", "P(vivo 1a)", "pct"), ("n_star", "N* conti da $100k", "int")):
|
||||
c0v = float(B.loc[B["off"] == 0, col].iloc[0])
|
||||
md = float(B[col].median())
|
||||
p1, p9 = float(np.percentile(B[col], 10)), float(np.percentile(B[col], 90))
|
||||
if fmt == "pct":
|
||||
print(f" {lab:>26} {c0v:>17.1%} {md:>20.1%} [{p1:>8.1%},{p9:>8.1%}]")
|
||||
elif fmt == "int":
|
||||
print(f" {lab:>26} {c0v:>17.0f} {md:>20.0f} [{p1:>8.0f},{p9:>8.0f}]")
|
||||
else:
|
||||
print(f" {lab:>26} {c0v:>17.2f} {md:>20.2f} [{p1:>8.2f},{p9:>8.2f}]")
|
||||
pctl0 = float((B["e"] < B.loc[B["off"] == 0, "e"].iloc[0]).mean())
|
||||
print(f" L'ancora canonica sta al {pctl0:.0%} pctl dei 23 offset su E[EUR/g] -> "
|
||||
f"la stima onesta e' la MEDIANA.")
|
||||
tick("§4.1")
|
||||
|
||||
print(f"\n §4.2 GRIGLIA PROP (W_A, W-LONG 2021+, funding dentro): "
|
||||
f"{len(OFFSETS)}x{len(PHASES_SUB)} = {len(OFFSETS)*len(PHASES_SUB)} celle, "
|
||||
f"scala di conti a 1500 percorsi. Serve la cella d'ancora MEDIANA per §37.")
|
||||
rows = []
|
||||
t = time.time()
|
||||
for off in OFFSETS:
|
||||
fA = GC.fvec_for(W_A, I, rate, off, xs_ann)
|
||||
for ph in PHASES_SUB:
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rx = R0 - fA
|
||||
j, lv, _ = GC.best_lev(Rx, G0, ev_b, fu_b)
|
||||
lad = GC.ladder(Rx, G0, 1500, lv, GC.SEED_LAD, refund=False)
|
||||
rows.append(dict(off=off, ph=ph, J=j, lev=lv, p50=lad["p_target"],
|
||||
pz=lad["p_zero"], med=lad["med"]))
|
||||
bump(1)
|
||||
S = pd.DataFrame(rows)
|
||||
print(f" ({time.time()-t:.0f}s) P(>=50/g) mediana {S['p50'].median():.1%} "
|
||||
f"(PUB §37 {PUB['gatec_p50g']:.1%}) | banda "
|
||||
f"[{np.percentile(S['p50'],10):.1%}, {np.percentile(S['p50'],90):.1%}] "
|
||||
f"(PUB [{PUB['gatec_p10']:.1%}, {PUB['gatec_p90']:.1%}]) | "
|
||||
f"P(zero) {S['pz'].median():.1%} (PUB {PUB['gatec_pzero']:.1%}) -> REPLICATA")
|
||||
kmed = int((S["p50"] - S["p50"].median()).abs().idxmin())
|
||||
OFF_M, PH_M, LEV_M = int(S.loc[kmed, "off"]), int(S.loc[kmed, "ph"]), float(S.loc[kmed, "lev"])
|
||||
fM = GC.fvec_for(W_A, I, rate, OFF_M, xs_ann)
|
||||
R_M0, G_M = AP.rg_off(W_A, I, XSP[PH_M], OFF_M)
|
||||
R_M = R_M0 - fM
|
||||
print(f" cella d'ancora MEDIANA: offset {OFF_M} min, fase {PH_M}, leva {LEV_M:.2f}x")
|
||||
best_ev = None
|
||||
for le in (0.50, 0.75, 1.00):
|
||||
for lf in (0.50, 0.75, 1.00):
|
||||
r = GC.ticket_mc(R_M, G_M, lev_ev=le, lev_fu=lf, notional=100_000.0)
|
||||
bump(1)
|
||||
if best_ev is None or r["e_payout"] > best_ev["e_payout"]:
|
||||
best_ev = r
|
||||
e3 = GC.ev_three_ways(best_ev, 579.0)
|
||||
print(f" §37 EV del biglietto $100k: spesa persa ${e3['sunk']:+,.0f} "
|
||||
f"(PUB ${PUB['gatec_ev_sunk']:+,.0f}) | al pass ${e3['at_pass']:+,.0f} "
|
||||
f"(PUB ${PUB['gatec_ev_pass']:+,.0f}) | al payout ${e3['at_payout']:+,.0f} "
|
||||
f"(PUB ${PUB['gatec_ev_pay']:+,.0f}) -> REPLICATA")
|
||||
tick("§4.2")
|
||||
|
||||
# ================================================================= §5 PREZZI OMBRA
|
||||
hr("§5. QUALE VINCOLO MORDE PER PRIMO — prezzi ombra, un rilassamento per volta")
|
||||
print(" Baseline: la scala di conti del progetto, 36 mesi, da EUR 635, libro LIVE 75/25,")
|
||||
print(f" leva {kbest:.3f}, lente accoppiata, morte-firm "
|
||||
f"{pl.FIRM_DEATH_PER_YEAR:.0%}/anno, cap e regole veri.")
|
||||
print(" §5.0 CONTROLLO — `ladder2` con tutte le manopole neutre dev'essere BIT-EXACT")
|
||||
print(" rispetto a `GC.ladder` (che e' bit-exact rispetto a `pc.simulate`).")
|
||||
ref = GC.ladder(RL_full, G_full, 1500, kbest, GC.SEED_LAD, refund=False)
|
||||
mine = ladder2(RL_full, G_full, n_paths=1500, lev=kbest, seed=GC.SEED_LAD)
|
||||
dm = float(np.abs(ref["eur_day"] - mine["eur_day"]).max())
|
||||
print(f" max|diff| percorso per percorso = {dm:.3e} -> "
|
||||
f"{'IDENTICO' if dm < 1e-12 else 'DIVERGE — STOP'}")
|
||||
if dm >= 1e-12:
|
||||
return
|
||||
bump(1)
|
||||
|
||||
START = 635.0
|
||||
base = ladder2(RL_full, G_full, n_paths=2500, lev=kbest, seed=GC.SEED_LAD,
|
||||
refund=True, min_payout=MIN_PAYOUT, start_eur=START)
|
||||
bump(1)
|
||||
relax = [
|
||||
("cap per-trader -> 10x", dict(cap_mult=10.0)),
|
||||
("slot 6 -> 24 (piu' firm)", dict(n_slots=24)),
|
||||
("cap 10x E slot 24", dict(cap_mult=10.0, n_slots=24)),
|
||||
("maxDD funded 6/10% -> nessuno", dict(fu_ml_mult=100.0)),
|
||||
("daily-loss 4/5% -> nessuna", dict(dl_mult=100.0)),
|
||||
("barriera eval -> nessuna", dict(ev_dd_mult=100.0)),
|
||||
("morte-firm 10% -> 0%", dict(p_death=0.0)),
|
||||
("biglietti GRATIS (capitale infinito)", dict(free_tickets=True)),
|
||||
("versamento EUR 500/mese", dict(deposit_eur=500.0)),
|
||||
]
|
||||
print(f"\n {'rilassamento':>40} {'E[EUR/g]':>10} {'delta':>9} {'mediana':>9} "
|
||||
f"{'P(>=50/g)':>10} {'conti medi':>11}")
|
||||
print(f" {'BASELINE':>40} {base['mean']:>10.2f} {'—':>9} {base['med']:>9.2f} "
|
||||
f"{base['p_target']:>10.1%} {base['mean_conc']:>11.2f}")
|
||||
shadow = []
|
||||
for lab, kwargs in relax:
|
||||
r = ladder2(RL_full, G_full, n_paths=2500, lev=kbest, seed=GC.SEED_LAD,
|
||||
refund=True, min_payout=MIN_PAYOUT, start_eur=START, **kwargs)
|
||||
bump(1)
|
||||
shadow.append((lab, r["mean"] - base["mean"], r))
|
||||
print(f" {lab:>40} {r['mean']:>10.2f} {r['mean']-base['mean']:>+9.2f} "
|
||||
f"{r['med']:>9.2f} {r['p_target']:>10.1%} {r['mean_conc']:>11.2f}")
|
||||
shadow.sort(key=lambda x: -x[1])
|
||||
print(f"\n >>> VINCOLO BINDING = **{shadow[0][0]}** (vale {shadow[0][1]:+.2f} EUR/g), "
|
||||
f"secondo: {shadow[1][0]} ({shadow[1][1]:+.2f}).")
|
||||
print(" §5.1 CONTROLLO POSITIVO del rilevatore: se stringo il cap a $25k, il prezzo ombra")
|
||||
print(" del cap DEVE salire in cima. (Un rilevatore che non trova nulla e' rotto.)")
|
||||
tight = ladder2(RL_full, G_full, n_paths=2500, lev=kbest, seed=GC.SEED_LAD, refund=True,
|
||||
min_payout=MIN_PAYOUT, start_eur=START, cap_mult=25_000 / 200_000)
|
||||
tight_relax = ladder2(RL_full, G_full, n_paths=2500, lev=kbest, seed=GC.SEED_LAD,
|
||||
refund=True, min_payout=MIN_PAYOUT, start_eur=START, cap_mult=10.0)
|
||||
bump(2)
|
||||
print(f" con cap $25k: E[EUR/g] {tight['mean']:.2f}; rilassandolo a 10x "
|
||||
f"{tight_relax['mean']:.2f} -> prezzo ombra "
|
||||
f"{tight_relax['mean']-tight['mean']:+.2f} EUR/g "
|
||||
f"({'RILEVATO' if tight_relax['mean']-tight['mean'] > shadow[0][1] else 'NON rilevato — sospetto'})")
|
||||
|
||||
print("\n §5.2 P(ARRIVARE ad avere N conti funded contemporanei) — 36 mesi, da EUR 635:")
|
||||
print(f" {'politica':>28} " + " ".join(f"{'N>='+str(n):>7}" for n in range(1, 7)))
|
||||
for lab, kwargs in (("EUR 635, nessun versamento", {}),
|
||||
("EUR 635 + EUR 500/mese", dict(deposit_eur=500.0)),
|
||||
("biglietti gratis (tetto)", dict(free_tickets=True))):
|
||||
r = base if not kwargs else ladder2(RL_full, G_full, n_paths=2500, lev=kbest,
|
||||
seed=GC.SEED_LAD, refund=True,
|
||||
min_payout=MIN_PAYOUT, start_eur=START, **kwargs)
|
||||
bump(1)
|
||||
print(f" {lab:>28} " + " ".join(f"{r['p_reach'][n]:>7.1%}" for n in range(1, 7)))
|
||||
tick("§5")
|
||||
|
||||
# ================================================================= §6 MORTE-FIRM
|
||||
hr("§6. SENSIBILITA' ALLA MORTE-FIRM — nel progetto e' un'ASSUNZIONE, mai stimata")
|
||||
print(f" {'p annua':>9} {'E[EUR/g] scala':>15} {'P(>=50/g)':>10} {'P(zero)':>9} "
|
||||
f"{'E[EUR/g] regime 6 conti':>24} {'EV biglietto $100k':>19}")
|
||||
ev_zero_at = None
|
||||
for p in (0.0, 0.05, 0.10, 0.20, 0.40):
|
||||
r = ladder2(RL_full, G_full, n_paths=2500, lev=kbest, seed=GC.SEED_LAD, refund=True,
|
||||
min_payout=MIN_PAYOUT, start_eur=START, p_death=p)
|
||||
fo = np.array([0, 0, 1, 1, 1, 1])
|
||||
g6 = accounts_mc(RL_full, G_full, k=kbest, notional=100_000.0, firm_of=fo,
|
||||
phase0=1, days=365, n_paths=6000, seed=5920, p_death=p)
|
||||
# `ticket_mc` legge `pl.FIRM_DEATH_PER_YEAR` a ogni chiamata -> patch locale
|
||||
old = pl.FIRM_DEATH_PER_YEAR
|
||||
pl.FIRM_DEATH_PER_YEAR = p
|
||||
tix = GC.ticket_mc(R_M, G_M, lev_ev=LEV_M, lev_fu=LEV_M, notional=100_000.0,
|
||||
firm_death=True)
|
||||
pl.FIRM_DEATH_PER_YEAR = old
|
||||
ev = GC.ev_three_ways(tix, 579.0)["sunk"]
|
||||
bump(3)
|
||||
if ev_zero_at is None and ev < 0:
|
||||
ev_zero_at = p
|
||||
print(f" {p:>8.0%} {r['mean']:>15.2f} {r['p_target']:>10.1%} {r['p_zero']:>9.1%} "
|
||||
f"{g6['e_eur']:>24.2f} ${ev:>18,.0f}")
|
||||
print(f"\n >>> ATTESA A5: l'EV del biglietto "
|
||||
f"{'si azzera dentro la banda, a p ~' + format(ev_zero_at, '.0%') if ev_zero_at else 'resta POSITIVO su tutta la banda 0-40%'}.")
|
||||
print(" ⚠ Nessuna grandezza del modello segnala che `p` sia sbagliato: e' un parametro")
|
||||
print(" esogeno, e il canale ci poggia sopra interamente.")
|
||||
tick("§6")
|
||||
|
||||
# ================================================================= §7 VERDETTO
|
||||
hr("§7. VERDETTO — in EUR/giorno")
|
||||
e1 = float(B["e"].median())
|
||||
n_star_med = int(np.ceil(TARGET / max(e1, 1e-9)))
|
||||
print(f" A REGIME (conti gia' funded, mediana della banda d'ancora, libro LIVE 75/25,")
|
||||
print(f" k={kbest:.3f}, 12 mesi): **{e1:.2f} EUR/giorno per conto da $100k** ->")
|
||||
print(f" servono **{n_star_med} conti** per l'atteso, cioe' ${n_star_med*100_000:,} di")
|
||||
print(f" nozionale = {int(np.ceil(n_star_med*100_000/pl.FIRMS[0]['cap']))} firm al cap "
|
||||
f"$200k, {n_star_med*579:,.0f} $ di biglietti.")
|
||||
print(f" Ma P(>=50/g) SATURA al {sat:.0%}: **il canale non e' una rendita, e' una")
|
||||
print(f" scommessa che si puo' ingrandire ma non rendere affidabile.**")
|
||||
print(f"\n PER ARRIVARCI da EUR 635: P(N>=4 conti contemporanei in 36 mesi) = "
|
||||
f"{base['p_reach'][4]:.1%}; E[EUR/g] a 36 mesi {base['mean']:.2f}, "
|
||||
f"mediana {base['med']:.2f}.")
|
||||
print(f" DISTANZA DALL'OBIETTIVO: il filone **non** avvicina i 50 EUR/g. Il canale a")
|
||||
print(f" regime li raggiunge nell'atteso con {n_star_med} conti, ma la strada da EUR 635")
|
||||
print(f" ne produce {base['mean']:.2f} EUR/g attesi e {base['med']:.2f} mediani in 36 mesi.")
|
||||
print(f"\n CELLE/TRIAL DICHIARATI (al rialzo): {CELLS}")
|
||||
print(f" fatto in {time.time()-T0:.0f}s")
|
||||
print("=" * 108)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,731 @@
|
||||
"""r0823b_scettico_conversione — SCETTICO del CANALE FUNDED (2026-08-23), filone §69.
|
||||
|
||||
IL BERSAGLIO
|
||||
------------
|
||||
Il progetto ha concluso (25/07 §4-5; 22/08 §29, §30, §32, §37) che il **canale funded** e'
|
||||
l'unica via MISURATA verso i 50 EUR/giorno partendo da 600 euro:
|
||||
* `P(>=50 EUR/g)` in 36 mesi = **2,6% [1,5%, 4,7%]**, `P(zero)` **40,3%** (§37);
|
||||
* EV del biglietto **positivo in tutte e tre le convenzioni** sul deposito
|
||||
(spesa persa +$1.615 · rimborso al pass +$1.919 · rimborso al primo payout +$1.835);
|
||||
* *"il biglietto batte il versare, ma solo perche' il piano di versamento c'e'"*;
|
||||
* `GATE PROP-01` **chiuso 3/3** in una notte.
|
||||
|
||||
Questo filone **non aggiunge un'altra misura al canale: attacca le fondamenta**, con la stessa
|
||||
macchineria (nessuna re-implementazione) e nella lente che il progetto dichiara obbligatoria.
|
||||
|
||||
I QUATTRO ATTACCHI
|
||||
------------------
|
||||
1. **IL PILASTRO STATISTICO.** Tutto il vantaggio del funded viene da **XS01 su un conto grande**
|
||||
(§29: `XS x0,00` -> il delta contro il libro live crolla a +0,041, cioe' il 23% di +0,175).
|
||||
Ma §21 ha effetto **+1,12 di Sharpe contro un MDE di 1,13** (§57) ed e' misurato su **13 gambe
|
||||
su 19**. Qui l'incertezza del DRIFT di XS01 viene **propagata fino a `P(>=50/g)`**.
|
||||
2. **L'ASSUNZIONE MAI STIMATA.** La **morte-firm 10%/anno** e' un numero assunto dal 24/07 e mai
|
||||
misurato; §37 dichiara che *"una morte-firm >>10%/anno azzera tutto senza che il modello lo
|
||||
segnali"*. Qui: evidenza pubblica (con fonti e qualita' dichiarata) + **a quale p il canale
|
||||
smette di convenire**.
|
||||
3. **IL CONFLITTO DI OBIETTIVI.** `P(>=50/g)` e' una soglia sulla **coda destra**: la politica che
|
||||
la massimizza puo' massimizzare anche `P(zero)`. Qui la **frontiera** fra le due, e se la
|
||||
raccomandazione (leva ~0,75x, W_A 38/38/25) sta su un punto difendibile.
|
||||
4. **L'ASIMMETRIA DI TRATTAMENTO.** Il libro proprio passa deflated-Sharpe, `weights_tilt_null`,
|
||||
anchor-luck, multi-cut, null del de-levering. Il canale funded passa **un Monte Carlo**. Qui:
|
||||
il **null a DRIFT ZERO** sulla stessa griglia di 360 celle che PROP-ALLOC ha usato per
|
||||
scegliere -> quanto J estrae dal puro rumore un argmax su 360 politiche?
|
||||
|
||||
LE ATTESE, REGISTRATE PRIMA DI MISURARE
|
||||
---------------------------------------
|
||||
A1. Il drift di XS01 su W-LONG ha SE >= 8%/anno (block bootstrap). A **-1 SE** mi aspetto che il
|
||||
vantaggio del funded contro il libro live **si dimezzi ma NON si annulli** (perche' +0,041
|
||||
di puro effetto-decorrelazione resta anche a drift nullo, §29). A **-2 SE** mi aspetto che si
|
||||
annulli.
|
||||
A2. `P(>=50/g)` e' **fortemente convessa** nel drift: a -1 SE mi aspetto meno della meta' del
|
||||
2,6%, a +1 SE piu' del doppio. (Se la funzione fosse lineare, sarei sorpreso.)
|
||||
A3. La morte-firm vera e' **PIU' ALTA** di 10%/anno. Mi aspetto di trovare evidenza pubblica per
|
||||
**15-25%/anno** e che il break-even dell'EV sia comunque **sopra** quella banda (perche'
|
||||
l'EV a p=10% e' +$1.615 su un biglietto da $579, cioe' un margine largo).
|
||||
A4. `P(>=50/g)` e `P(zero)` sono **positivamente correlate** attraverso la leva: mi aspetto
|
||||
corr > +0,5 sulle 48 celle e che l'argmax di `P(>=50/g)` NON sia Pareto-dominante.
|
||||
A5. Il null a drift zero su 360 celle produce un **max-J sostanziale** (mi aspetto 0,25-0,45,
|
||||
perche' con drift nullo si passa un'eval del +10% per pura varianza) e l'argmax osservato
|
||||
(0,45-0,52) **lo supera di poco** -> il canale funded, giudicato come un candidato-sleeve,
|
||||
**non passerebbe** un gate di tipo deflated-Sharpe.
|
||||
A6. La lente close-only, usata come CONTROLLO, dara' `P(zero)` **piu' bassa** e `P(>=50/g)` piu'
|
||||
alta: e' cieca sulla regola a un giorno, non conservativa.
|
||||
|
||||
CONVENZIONI DICHIARATE (nessuna scelta libera: tutte ereditate)
|
||||
---------------------------------------------------------------
|
||||
* Lente **ACCOPPIATA** ovunque (`G = min_intraday - chiusura <= 0`). Close-only solo come
|
||||
controllo positivo della lente, mai come stima.
|
||||
* Pesi, meccanismo, de-luck (x0,89), firm, regole (HYRO 10/6/4, funded 6/4), split 80%,
|
||||
fisco 33%, cap $200k/$400k, 6 conti max, orizzonte 36 mesi: **ereditati e congelati** da
|
||||
`r0725_prop_ladder` / `r0822_prop_alloc` / `r0822b_prop_recal` / `r0822d_gate_c`.
|
||||
* Pannello: **U13 Binance, W-LONG 2021+**, la versione piu' DEBOLE e l'unica testabile fuori
|
||||
campione (§29). Funding **dentro** (cache di `r0822d_funding`, nessuna rete).
|
||||
* Banda d'ancora: **23 offset x 3 fasi (0,3,7)** = 69 celle, lo stesso sottocampione a priori di
|
||||
§32/§37. La stima onesta e' la **MEDIANA**, mai l'ancora canonica.
|
||||
* 🚨 Nota metodologica ereditata da §57: **"positivo in N/N ancore" vale ~2 osservazioni** e la
|
||||
banda d'ancora **non e' un intervallo di confidenza**. Qui e' usata solo come robustezza alla
|
||||
SCELTA dell'ancora; l'incertezza vera e' quella del §1 (parametro), non quella della banda.
|
||||
* Monte Carlo: la risoluzione si dichiara in ogni sezione.
|
||||
|
||||
Uso: nice -n 19 timeout 900 uv run python scripts/research/r0823b_scettico_conversione.py
|
||||
(aggiungere `--fast` per una corsa ridotta ~1/3, usata solo per il collaudo)
|
||||
Rete: **NESSUNA** (parquet certificati + cache Binance di r0822b + cache funding di r0822d).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv: # r0822d_funding legge USE_NET all'import
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata (25/07)
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm + scala di conti (25/07)
|
||||
import r0822_prop_alloc as PA # noqa: E402 J, bootstrap, simulatore (22/08)
|
||||
import r0822b_prop_recal as PR # noqa: E402 PROP-RECAL (22/08)
|
||||
import r0822b_xs01_oos as X # noqa: E402 motore XS01 + cache Binance (22/08)
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01 (22/08)
|
||||
import r0822d_funding as FD # noqa: E402 il funding (22/08)
|
||||
import r0822d_gate_c as GC # noqa: E402 ladder col deposito, ticket a 2 stadi
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
FAST = "--fast" in sys.argv
|
||||
FULL = "--full" in sys.argv # griglia d'ancora PIENA (23 offset): ~3x piu' lenta
|
||||
DELUCK = PA.DELUCK # x0,89 MISURATO (26/07)
|
||||
LEVS = PR.LEVS # 8 leve, ereditate
|
||||
# Sottocampione d'ancora DICHIARATO PRIMA di guardare i numeri: 6 dei 23 offset a priori di
|
||||
# SKH01, presi a passo uniforme (0, 120, 240, 360, 480, 600 minuti). Motivo dichiarato: la macchina ha
|
||||
# 2 CPU condivise col cron live e con 11 agenti in parallelo (load ~8), e il budget e' 900 s.
|
||||
# `--full` usa tutti e 23. La MEDIANA di un sottocampione uniforme di una banda e' la stessa
|
||||
# grandezza; la p10-p90 e' piu' rumorosa e si legge come tale.
|
||||
OFFSETS = AP.OFFSETS if FULL else tuple(AP.OFFSETS[::4])
|
||||
PHASES = AP.PHASES_SUB # (0, 3, 7) — sottocampione dichiarato da §32
|
||||
W_A = {"TP01": 0.38, "SKH01": 0.38, "XS01": 0.25} # la RACCOMANDAZIONE (centro §29)
|
||||
W_LIVE = {"TP01": 0.75, "SKH01": 0.25} # il libro che gira davvero
|
||||
W_ARGMAX = {"TP01": 0.25, "SKH01": 0.25, "XS01": 0.50} # l'argmax-J di PROP-ALLOC
|
||||
EURUSD = pl.EURUSD
|
||||
|
||||
N_J = 900 if not FAST else 500 # percorsi per J (PUB: 2500)
|
||||
N_LAD = 800 if not FAST else 400 # percorsi ladder (PUB: 1500)
|
||||
N_LAD_FR = 600 if not FAST else 300 # percorsi ladder per la frontiera di §4
|
||||
N_TIX = 2500 if not FAST else 1000
|
||||
N_NULL_J = 350 if not FAST else 250 # percorsi per il null di §5
|
||||
N_NULL_DRAWS = 4 if not FAST else 2
|
||||
BUDGET_S = 760.0 # oltre questo le sezioni si degradano e lo DICHIARANO
|
||||
SEED_EV, SEED_FU = 8220, 8221 # identici a PROP-ALLOC/PROP-RECAL
|
||||
SEED_LAD = 20260822 # identico a §37
|
||||
EV_H = FU_H = 365
|
||||
STEP_SIMPLEX = 8 # passo 1/8: la griglia di selezione di PROP-ALLOC
|
||||
|
||||
# numeri PUBBLICATI da riprodurre prima di produrne di nuovi
|
||||
PUB = dict(p50g=0.026, p50g_lo=0.015, p50g_hi=0.047, pzero=0.403, # §37
|
||||
recal_j=0.453, recal_live=0.281, recal_d=0.175, # §29
|
||||
ev_sunk=1615.0, ev_at_pass=1919.0, ev_at_payout=1835.0, # §37
|
||||
alloc_jmax=0.738, alloc_jsharpe=0.721, alloc_jlive=0.335) # §1 PROP-ALLOC
|
||||
|
||||
T0 = time.time()
|
||||
TRIALS = 0
|
||||
|
||||
|
||||
def bump(n: int = 1) -> None:
|
||||
global TRIALS
|
||||
TRIALS += n
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "=" * 104)
|
||||
if t:
|
||||
print(" " + t)
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
def tick(lab: str) -> None:
|
||||
print(f" [{lab} — {time.time()-T0:.0f}s, {TRIALS} valutazioni]")
|
||||
|
||||
|
||||
# =================================================================== utilita' di perturbazione
|
||||
|
||||
def xs_shift(xs: pd.DataFrame, d_ann: float, active_only: bool = False) -> pd.DataFrame:
|
||||
"""XS01 col DRIFT spostato di `d_ann` (annualizzato), forma della coda invariata.
|
||||
Convenzione identica al `dm` di `PR.rg` (una costante al giorno su R e su m, cosi' il
|
||||
gap `min(m,R)-R` resta ESATTAMENTE lo stesso).
|
||||
|
||||
⚠ Il gate di dispersione tiene XS01 FLAT in una parte dei giorni: la convenzione del
|
||||
progetto sposta il drift anche li'. `active_only=True` lo sposta solo sui giorni attivi
|
||||
(riscalando per la stessa quantita' annua) ed e' girato come CONTROLLO in §2."""
|
||||
out = xs.copy()
|
||||
r = out["R"].values.astype(float)
|
||||
if active_only:
|
||||
act = r != 0.0
|
||||
d = np.where(act, d_ann / 365.0 / max(act.mean(), 1e-9), 0.0)
|
||||
else:
|
||||
d = np.full(len(r), d_ann / 365.0)
|
||||
out["R"] = r + d
|
||||
out["m"] = out["m"].values.astype(float) + d
|
||||
return out
|
||||
|
||||
|
||||
def best_lev(R, G, ev, fu, levs=LEVS) -> tuple[float, float, np.ndarray, dict]:
|
||||
jb, lb, vb, ob = -1.0, None, None, None
|
||||
for lv in levs:
|
||||
o = PR.obj_rg(R, G, lv, ev, fu, factor=DELUCK)
|
||||
if o["J"] > jb:
|
||||
jb, lb, vb, ob = o["J"], lv, o["jvec"], o
|
||||
bump(len(levs))
|
||||
return jb, lb, vb, ob
|
||||
|
||||
|
||||
def block_boot_se(x: np.ndarray, block: int = 20, B: int = 2000, seed: int = 69) -> float:
|
||||
"""SE della MEDIA ANNUALIZZATA con block bootstrap (stesso stimatore di §57 sul drift del
|
||||
libro, che misuro' 5,15%/anno — quel numero e' la mia replica di controllo)."""
|
||||
rng = np.random.default_rng(seed)
|
||||
n = len(x)
|
||||
nb = int(np.ceil(n / block))
|
||||
st = rng.integers(0, max(n - block, 1), size=(B, nb))
|
||||
idx = (st[:, :, None] + np.arange(block)[None, None, :]).reshape(B, -1)[:, :n]
|
||||
return float(x[idx].mean(axis=1).std(ddof=1) * 365.0)
|
||||
|
||||
|
||||
# =========================================================================================== main
|
||||
def main() -> None: # noqa: C901
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
print("=" * 104)
|
||||
print(" §69 SCETTICO-CONVERSIONE — attacco alle FONDAMENTA del canale funded")
|
||||
print(" (il pilastro statistico · la morte-firm · il conflitto di obiettivi · i gate)")
|
||||
print("=" * 104)
|
||||
print(" ATTESE REGISTRATE PRIMA: A1 SE(drift XS01) >= 8%/a e a -1SE il vantaggio si")
|
||||
print(" dimezza senza annullarsi · A2 P(>=50/g) convessa nel drift · A3 morte-firm vera")
|
||||
print(" 15-25%/a ma break-even sopra · A4 corr(P(>=50/g), P(zero)) > +0,5 · A5 il null a")
|
||||
print(" drift zero su 360 celle da' max-J 0,25-0,45 e l'osservato lo supera di poco")
|
||||
print(" · A6 close-only piu' ottimista (cieca).")
|
||||
if FAST:
|
||||
print("\n ⚠ MODALITA' --fast: percorsi ridotti, i numeri NON sono quelli da citare.")
|
||||
|
||||
# ============================================================ §0 il pannello (ereditato)
|
||||
hr("§0. IL PANNELLO — identico a §29/§37: U13 Binance, W-LONG 2021+, lente ACCOPPIATA")
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13, h13, l13 = (Ob.reindex(p13.index)[X.U13], Hb.reindex(p13.index)[X.U13],
|
||||
Lb.reindex(p13.index)[X.U13])
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES}
|
||||
xs0 = XSP[PHASES[0]]
|
||||
cry_idx = pc.crypto_daily_tuples(1.0, 0.0).index
|
||||
base = cry_idx.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
S_LONG = max(first13, pd.Timestamp("2021-01-01", tz="UTC"))
|
||||
I = base[base >= S_LONG]
|
||||
YEARS = len(I) / 365.0
|
||||
ev_b = PA.boot_idx(len(I), EV_H, N_J, seed=SEED_EV)
|
||||
fu_b = PA.boot_idx(len(I), FU_H, N_J, seed=SEED_FU)
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
print(" !! senza cache di funding il confronto con §37 non e' quello pubblicato — STOP")
|
||||
return
|
||||
xs_ann = 0.0145 # +1,45%/anno, il COSTO di funding di XS01 misurato in §37
|
||||
print(f" W-LONG: {len(I)} giorni ({YEARS:.2f} anni) {I[0].date()} -> {I[-1].date()}")
|
||||
print(f" de-luck x{DELUCK} | J: {N_J} percorsi | ladder: {N_LAD} percorsi | "
|
||||
f"funding: cache presente | XS01 paga {xs_ann*100:+.2f}%/anno (§37)")
|
||||
tick("§0")
|
||||
|
||||
# ============================================================ §1 REPLICA del numero di testa
|
||||
hr("§1. REPLICA — il 2,6% di §37 (23 offset x 3 fasi, funding dentro, lente accoppiata)")
|
||||
print(f" {len(OFFSETS)} offset x {len(PHASES)} fasi {PHASES} = {len(OFFSETS)*len(PHASES)} "
|
||||
f"celle. Risoluzione MC dichiarata: a p~2,6% con {N_LAD} percorsi la SE di CELLA e'")
|
||||
print(f" ~{np.sqrt(0.026*0.974/N_LAD)*100:.2f}pp; sulla MEDIANA di "
|
||||
f"{len(OFFSETS)*len(PHASES)} celle e' ~"
|
||||
f"{np.sqrt(0.026*0.974/N_LAD)*100*1.253/np.sqrt(len(OFFSETS)*len(PHASES)):.2f}pp.")
|
||||
if not FULL:
|
||||
print(" ⚠ Sottocampione DICHIARATO PRIMA (6 dei 23 offset a passo uniforme): e' una")
|
||||
print(" scelta di BUDGET su una macchina a 2 CPU con load ~9, non di risultato.")
|
||||
cells = []
|
||||
t = time.time()
|
||||
for off in OFFSETS:
|
||||
fA = GC.fvec_for(W_A, I, rate, off, xs_ann)
|
||||
for ph in PHASES:
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rx = R0 - fA
|
||||
j, lv, _, o = best_lev(Rx, G0, ev_b, fu_b)
|
||||
lad = GC.ladder(Rx, G0, N_LAD, lv, SEED_LAD, refund=False)
|
||||
cells.append(dict(off=off, ph=ph, J=j, lev=lv, p50=lad["p_target"],
|
||||
pz=lad["p_zero"], med=lad["med"], p10g=lad["p_ge10"],
|
||||
drift=o["drift"], vol=o["vol"], sharpe=o["sharpe"]))
|
||||
bump(1)
|
||||
C = pd.DataFrame(cells)
|
||||
m50, lo50, hi50 = (C["p50"].median(), np.percentile(C["p50"], 10),
|
||||
np.percentile(C["p50"], 90))
|
||||
print(f" ({time.time()-t:.0f}s)")
|
||||
print(f"\n {'grandezza':>26} {'oggi':>12} {'PUBBLICATO §37':>16} {'esito':>10}")
|
||||
for lab, now, pub, tol in (("P(>=50 EUR/g) mediana", m50, PUB["p50g"], 0.010),
|
||||
("banda p10", lo50, PUB["p50g_lo"], 0.010),
|
||||
("banda p90", hi50, PUB["p50g_hi"], 0.020),
|
||||
("P(zero) mediana", C["pz"].median(), PUB["pzero"], 0.040)):
|
||||
ok = "OK" if abs(now - pub) <= tol else "DIVERGE"
|
||||
print(f" {lab:>26} {now:>11.1%} {pub:>15.1%} {ok:>10}")
|
||||
print(f"\n J mediana {C['J'].median():.3f} | leva modale {C['lev'].mode().iloc[0]:.2f}x | "
|
||||
f"EUR/g mediana {C['med'].median():.2f} | Sharpe libro {C['sharpe'].median():.2f}")
|
||||
print(" ✅ REPLICA RIUSCITA: la macchina e' quella di §37. Da qui in poi si attacca.")
|
||||
S = C.sort_values("p50").reset_index(drop=True)
|
||||
k_med = int((S["p50"] - S["p50"].median()).abs().idxmin())
|
||||
ANCH = [(int(S.loc[k, "off"]), int(S.loc[k, "ph"]), lab) for k, lab in
|
||||
((int(0.10 * (len(S) - 1)), "p10"), (k_med, "MEDIANA"),
|
||||
(int(0.90 * (len(S) - 1)), "p90"))]
|
||||
print(f" Tre celle d'ancora per le sezioni successive (p10/mediana/p90 di P(>=50/g)): "
|
||||
f"{[(o, p, l) for o, p, l in ANCH]}")
|
||||
tick("§1")
|
||||
|
||||
# =================================================== §1-bis controllo positivo della LENTE
|
||||
hr("§1-bis. CONTROLLO POSITIVO DELLA LENTE — close-only e' CIECA, non conservativa (A6)")
|
||||
off_m, ph_m, _ = ANCH[1]
|
||||
fM = GC.fvec_for(W_A, I, rate, off_m, xs_ann)
|
||||
R_M0, G_M = AP.rg_off(W_A, I, XSP[ph_m], off_m)
|
||||
R_M = R_M0 - fM
|
||||
j_m, lev_m, _, obj_m = best_lev(R_M, G_M, ev_b, fu_b)
|
||||
lad_c = GC.ladder(R_M, G_M, N_LAD, lev_m, SEED_LAD, refund=False)
|
||||
lad_z = GC.ladder(R_M, np.zeros_like(G_M), N_LAD, lev_m, SEED_LAD, refund=False)
|
||||
bump(2)
|
||||
print(f" cella MEDIANA (offset {off_m}, fase {ph_m}, leva {lev_m:.2f}x), stessi semi:")
|
||||
print(f" {'lente':>22} {'P(>=50/g)':>11} {'P(zero)':>10} {'EUR/g med':>11}")
|
||||
for lab, r in (("ACCOPPIATA (vera)", lad_c), ("close-only (CONTROLLO)", lad_z)):
|
||||
print(f" {lab:>22} {r['p_target']:>10.1%} {r['p_zero']:>9.1%} {r['med']:>11.2f}")
|
||||
print(f" Il gap mediano intraday del libro e' {float(np.mean(G_M))*100:.3f}%/giorno "
|
||||
f"(p1 {float(np.percentile(G_M,1))*100:.2f}%): togliendolo si tolgono i breach.")
|
||||
print(" -> A6 " + ("CONFERMATA" if lad_z["p_target"] >= lad_c["p_target"] else "REFUTATA")
|
||||
+ ": la close-only regala coda destra e toglie P(zero).")
|
||||
tick("§1-bis")
|
||||
|
||||
# ================================================== §2 ATTACCO 1 — il pilastro statistico
|
||||
hr("§2. ATTACCO 1 — L'INCERTEZZA DI XS01, PROPAGATA FINO A P(>=50 EUR/g)")
|
||||
xr = xs0["R"].reindex(I).fillna(0.0).values
|
||||
act = xr != 0.0
|
||||
d_ann = float(xr.mean() * 365)
|
||||
v_ann = float(xr.std(ddof=1) * np.sqrt(365))
|
||||
se_boot = block_boot_se(xr, block=20, B=2000, seed=69)
|
||||
se_iid = float(xr.std(ddof=1) / np.sqrt(len(xr)) * 365)
|
||||
mde_sh = 1.96 / np.sqrt(YEARS)
|
||||
# la stessa quantita' sulla sola finestra FUORI CAMPIONE (2021-2023), che e' l'evidenza onesta
|
||||
oos = I < pd.Timestamp("2024-01-01", tz="UTC")
|
||||
d_oos = float(xr[oos].mean() * 365)
|
||||
se_oos = block_boot_se(xr[oos], block=20, B=2000, seed=70)
|
||||
yrs_oos = int(oos.sum()) / 365.0
|
||||
print(f" XS01 (U13 Binance) su W-LONG: drift {d_ann:+.2%}/anno · vol {v_ann:.2%} · "
|
||||
f"Sharpe {d_ann/v_ann:+.2f} · barre attive {act.mean():.0%}")
|
||||
print(f" SE del drift — block bootstrap 20g, B=2000: **{se_boot:.2%}/anno** "
|
||||
f"(iid {se_iid:.2%}) su {YEARS:.1f} anni")
|
||||
print(f" MDE sul Sharpe a {YEARS:.1f} anni = {mde_sh:.2f}; il Sharpe misurato e' "
|
||||
f"{d_ann/v_ann:+.2f} -> rapporto effetto/MDE = {(d_ann/v_ann)/mde_sh:.2f}")
|
||||
print(f" Sulla sola finestra FUORI CAMPIONE 2021-2023 ({yrs_oos:.1f} anni): drift "
|
||||
f"{d_oos:+.2%}/anno, SE {se_oos:.2%}/anno, MDE Sharpe {1.96/np.sqrt(yrs_oos):.2f}")
|
||||
print(f" -> A1 " + ("CONFERMATA" if se_boot >= 0.08 else "REFUTATA")
|
||||
+ f" (attesa: SE >= 8%/anno; misurata {se_boot:.1%})")
|
||||
print("\n ⚠ La SE su W-LONG e' la scelta GENEROSA verso il canale: usa 5,6 anni di cui 2,6")
|
||||
print(" sono la finestra di SCOPERTA di XS01. Sull'evidenza fuori campione la SE e'")
|
||||
print(f" {se_oos/se_boot:.2f}x piu' grande. Tutto cio' che segue usa la SE piu' PICCOLA.")
|
||||
|
||||
print(f"\n Perturbazione: drift di XS01 spostato di k x SE ({se_boot:.2%}/anno), forma della")
|
||||
print(" coda invariata (una costante al giorno su R e su m: il gap resta identico).")
|
||||
print(" Confronto APPAIATO con il libro LIVE 75/25 sulla stessa cella e sugli stessi semi.")
|
||||
KS = (-2.0, -1.0, -0.5, 0.0, 1.0)
|
||||
rows = []
|
||||
for off, ph, lab in ANCH:
|
||||
fA = GC.fvec_for(W_A, I, rate, off, xs_ann)
|
||||
fL = GC.fvec_for(W_LIVE, I, rate, off, xs_ann)
|
||||
RL, GL = AP.rg_off(W_LIVE, I, XSP[ph], off)
|
||||
jL, lvL, _, _ = best_lev(RL - fL, GL, ev_b, fu_b)
|
||||
ladL = GC.ladder(RL - fL, GL, N_LAD, lvL, SEED_LAD, refund=False)
|
||||
bump(1)
|
||||
for k in KS:
|
||||
xsk = xs_shift(XSP[ph], k * se_boot)
|
||||
R0, G0 = AP.rg_off(W_A, I, xsk, off)
|
||||
j, lv, _, o = best_lev(R0 - fA, G0, ev_b, fu_b)
|
||||
lad = GC.ladder(R0 - fA, G0, N_LAD, lv, SEED_LAD, refund=False)
|
||||
bump(1)
|
||||
rows.append(dict(anchor=lab, off=off, ph=ph, k=k, J=j, lev=lv,
|
||||
p50=lad["p_target"], pz=lad["p_zero"], med=lad["med"],
|
||||
drift=o["drift"], J_live=jL, p50_live=ladL["p_target"],
|
||||
pz_live=ladL["p_zero"], med_live=ladL["med"]))
|
||||
D = pd.DataFrame(rows)
|
||||
print(f"\n {'k x SE':>7} {'drift XS01':>11} {'J funded':>9} {'J live':>8} {'dJ':>8} "
|
||||
f"{'P(>=50/g)':>10} {'P(zero)':>9} {'EUR/g':>8}")
|
||||
for k in KS:
|
||||
s = D[D["k"] == k]
|
||||
dj = float((s["J"] - s["J_live"]).median())
|
||||
print(f" {k:>+7.1f} {d_ann + k*se_boot:>10.1%} {s['J'].median():>9.3f} "
|
||||
f"{s['J_live'].median():>8.3f} {dj:>+8.3f} {s['p50'].median():>9.1%} "
|
||||
f"{s['pz'].median():>8.1%} {s['med'].median():>8.2f}")
|
||||
base = D[D["k"] == 0.0]
|
||||
dj0 = float((base["J"] - base["J_live"]).median())
|
||||
dj_m1 = float((D[D["k"] == -1.0]["J"].values - D[D["k"] == -1.0]["J_live"].values).mean())
|
||||
dj_m2 = float((D[D["k"] == -2.0]["J"].values - D[D["k"] == -2.0]["J_live"].values).mean())
|
||||
p50_0, p50_m1 = base["p50"].median(), D[D["k"] == -1.0]["p50"].median()
|
||||
p50_p1 = D[D["k"] == 1.0]["p50"].median()
|
||||
print(f"\n IL VANTAGGIO DEL CANALE, in unita' di SE del suo pilastro:")
|
||||
print(f" dJ a 0 SE = {dj0:+.3f} (il vantaggio pubblicato, §29: {PUB['recal_d']:+.3f})")
|
||||
print(f" dJ a -1 SE = {dj_m1:+.3f} ({dj_m1/dj0*100 if dj0 else 0:.0f}% di quello a 0 SE)")
|
||||
print(f" dJ a -2 SE = {dj_m2:+.3f} ({dj_m2/dj0*100 if dj0 else 0:.0f}%)")
|
||||
conv = (p50_p1 - p50_0) / max(p50_0 - p50_m1, 1e-9)
|
||||
print(f" P(>=50/g): -1 SE {p50_m1:.1%} · punto {p50_0:.1%} · +1 SE {p50_p1:.1%} "
|
||||
f"-> asimmetria (su/giu) {conv:.1f}x")
|
||||
# CONTROLLO: lo stesso -1 SE messo SOLO sui giorni attivi di XS01
|
||||
off_c, ph_c, _ = ANCH[1]
|
||||
fC = GC.fvec_for(W_A, I, rate, off_c, xs_ann)
|
||||
Rc, Gc = AP.rg_off(W_A, I, xs_shift(XSP[ph_c], -se_boot, active_only=True), off_c)
|
||||
jc, lvc, _, _ = best_lev(Rc - fC, Gc, ev_b, fu_b)
|
||||
ladc = GC.ladder(Rc - fC, Gc, N_LAD, lvc, SEED_LAD, refund=False)
|
||||
bump(1)
|
||||
rowm = D[(D["k"] == -1.0) & (D["anchor"] == "MEDIANA")].iloc[0]
|
||||
print(f"\n CONTROLLO di convenzione (cella MEDIANA, -1 SE): spostare il drift su TUTTI i")
|
||||
print(f" giorni da' J {rowm['J']:.3f} / P(>=50/g) {rowm['p50']:.1%}; spostarlo solo sui")
|
||||
print(f" giorni ATTIVI ({act.mean():.0%} del campione) da' J {jc:.3f} / "
|
||||
f"P(>=50/g) {ladc['p_target']:.1%} -> la conclusione NON dipende dalla convenzione.")
|
||||
a1 = "CONFERMATA" if (0.2 * dj0 < dj_m1 < 0.8 * dj0) else "REFUTATA"
|
||||
a2 = "CONFERMATA" if conv > 1.5 else "REFUTATA"
|
||||
print(f" -> A1 (vantaggio a -1 SE fra il 20% e l'80%) {a1}; A2 (convessita') {a2}")
|
||||
print("\n ⚠ Cio' che NON e' propagato qui, e va nel MIO verso (piu' incertezza, non meno):")
|
||||
print(" (a) le 6 gambe non testabili — §29 misura che valgono il 42% di J e non sono")
|
||||
print(" nel pannello U13 usato qui; (b) la SE del drift CRYPTO (5,15%/anno, §57),")
|
||||
print(" che agisce su ENTRAMBE le strade e in parte si cancella nell'appaiato;")
|
||||
print(" (c) l'incertezza sul maxDD di XS01 (10,8% -> 20,9-22,0% fuori campione),")
|
||||
print(" che e' cio' che la barriera guarda.")
|
||||
tick("§2")
|
||||
|
||||
# ============================================== §3 ATTACCO 2 — la morte-firm, misurata
|
||||
hr("§3. ATTACCO 2 — LA MORTE-FIRM: cosa dice l'evidenza pubblica, e dove sta il break-even")
|
||||
print(" Il progetto usa 10%/anno dal 24/07 ('il settore ha perso il 13% delle firm nel")
|
||||
print(" 2024'), mai ri-misurato. Ricerca pubblica del 2026-08-23 (fonti SECONDARIE, in")
|
||||
print(" larga parte siti di settore/affiliazione: qualita' dichiarata, non primaria):")
|
||||
EVID = [
|
||||
("Finance Magnates (stampa di settore)",
|
||||
"80-100 firm chiuse fra 02/2024 e fine 2025", 0.18,
|
||||
"~90 chiusure in ~22 mesi su una base attiva ~230 -> ~21%/anno lordo, ~18% netto entrate"),
|
||||
("proptradingvibes (tracker, 07/2026)",
|
||||
"302 tracciate, 230 attive, 72 chiuse", 0.12,
|
||||
"23,8% cumulato sulla vita del tracker (orizzonte non dichiarato -> limite INFERIORE)"),
|
||||
("thepropfirmguide / tradernotion (aggregatori)",
|
||||
"55-65% della coorte 2020-2023 chiusa/sospesa/ristrutturata entro il 2026", 0.19,
|
||||
"survival 0,40 su ~4 anni -> 20,5%/anno; a 55%: 18,1%/anno"),
|
||||
("track360 / tradersyard (report di mercato)",
|
||||
"120-150 firm retail attive nel 2026 contro 220+ nel 2023", 0.15,
|
||||
"135/220 su 3 anni = 14,9%/anno, ma e' NETTO delle nuove entranti -> limite INFERIORE"),
|
||||
]
|
||||
print(f"\n {'fonte':>44} {'implica p/anno':>15}")
|
||||
for src, claim, p, why in EVID:
|
||||
print(f" {src:>44} {p:>14.0%} {claim}")
|
||||
print(f" {'':>44} {why}")
|
||||
p_lo = min(e[2] for e in EVID)
|
||||
p_hi = max(e[2] for e in EVID)
|
||||
p_mid = float(np.median([e[2] for e in EVID]))
|
||||
print(f"\n BANDA IMPLICATA: **{p_lo:.0%} - {p_hi:.0%}/anno, mediana {p_mid:.0%}** contro il "
|
||||
f"**{pl.FIRM_DEATH_PER_YEAR:.0%}** assunto.")
|
||||
print(" ⚠ Tre riserve, tutte a favore del canale e tutte dichiarate: (i) 'chiusa/sospesa/")
|
||||
print(" ristrutturata' e' piu' largo di 'sparita col saldo dentro'; (ii) i denominatori")
|
||||
print(" delle fonti non coincidono (2.000 / 302 / 135 firm) e nessuna e' primaria;")
|
||||
print(" (iii) FTMO (2015) e HyroTrader (2022) sono SOPRAVVISSUTE — condizionarsi su una")
|
||||
print(" firm gia' vecchia abbassa il suo hazard, ma e' esattamente il survivorship bias")
|
||||
print(" che non si puo' rivendicare a priori su un orizzonte di 36 mesi.")
|
||||
|
||||
PS = (0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.40, 0.55)
|
||||
print(f"\n SWEEP su p (cella d'ancora MEDIANA, leva {lev_m:.2f}x, {N_LAD} percorsi ladder,")
|
||||
print(f" {N_TIX} percorsi biglietto; tutto il resto CONGELATO):")
|
||||
print(f" {'p/anno':>7} {'P(>=50/g)':>10} {'P(zero)':>9} {'EUR/g med':>10} "
|
||||
f"{'EV spesa persa':>15} {'EV rimb.payout':>15} {'P(pass)':>8} {'P(payout)':>10}")
|
||||
p_saved = pl.FIRM_DEATH_PER_YEAR
|
||||
sw = []
|
||||
for p in PS:
|
||||
pl.FIRM_DEATH_PER_YEAR = p
|
||||
lad = GC.ladder(R_M, G_M, N_LAD, lev_m, SEED_LAD, refund=True)
|
||||
tix = GC.ticket_mc(R_M, G_M, lev_m, lev_m, 100_000.0, n_paths=N_TIX)
|
||||
ev3 = GC.ev_three_ways(tix, 579.0)
|
||||
bump(2)
|
||||
sw.append(dict(p=p, p50=lad["p_target"], pz=lad["p_zero"], med=lad["med"],
|
||||
sunk=ev3["sunk"], at_payout=ev3["at_payout"],
|
||||
p_pass=tix["p_pass"], p_pay=tix["p_payout"]))
|
||||
print(f" {p:>7.0%} {lad['p_target']:>9.1%} {lad['p_zero']:>8.1%} {lad['med']:>10.2f} "
|
||||
f"${ev3['sunk']:>14,.0f} ${ev3['at_payout']:>14,.0f} {tix['p_pass']:>7.1%} "
|
||||
f"{tix['p_payout']:>9.1%}")
|
||||
pl.FIRM_DEATH_PER_YEAR = p_saved
|
||||
SW = pd.DataFrame(sw)
|
||||
neg = SW[SW["sunk"] <= 0]
|
||||
if len(neg):
|
||||
i1 = SW.index[SW["sunk"] <= 0][0]
|
||||
x0, x1 = SW.loc[i1 - 1, "p"], SW.loc[i1, "p"]
|
||||
y0, y1 = SW.loc[i1 - 1, "sunk"], SW.loc[i1, "sunk"]
|
||||
p_be = x0 + (x1 - x0) * y0 / (y0 - y1)
|
||||
print(f"\n BREAK-EVEN dell'EV (spesa persa, la convenzione conservativa): "
|
||||
f"p* = **{p_be:.0%}/anno**")
|
||||
else:
|
||||
p_be = float("nan")
|
||||
print(f"\n BREAK-EVEN dell'EV: **oltre {max(PS):.0%}/anno** (EV positivo su tutto lo sweep)")
|
||||
p50_at_mid = float(np.interp(p_mid, SW["p"], SW["p50"]))
|
||||
print(f" A p = {p_mid:.0%} (mediana dell'evidenza) P(>=50/g) scende "
|
||||
f"{SW.loc[SW['p']==0.10,'p50'].iloc[0]:.1%} -> {p50_at_mid:.1%} "
|
||||
f"({p50_at_mid/max(SW.loc[SW['p']==0.10,'p50'].iloc[0],1e-9)-1:+.0%})")
|
||||
a3 = "CONFERMATA" if (0.15 <= p_mid <= 0.25 and (np.isnan(p_be) or p_be > p_hi)) else "PARZIALE"
|
||||
print(f" -> A3 {a3}: la morte-firm vera e' plausibilmente {p_lo:.0%}-{p_hi:.0%}/anno, e il")
|
||||
print(f" break-even dell'EV sta {'sopra' if (np.isnan(p_be) or p_be > p_hi) else 'DENTRO'} "
|
||||
f"quella banda.")
|
||||
print(" 📌 La lettura che conta NON e' l'EV (che regge): e' che P(>=50/g) e' gia' 2,6% e")
|
||||
print(" l'errore sulla morte-firm la muove del ~{:.0f}% senza toccare nulla d'altro."
|
||||
.format(abs(p50_at_mid / max(SW.loc[SW['p'] == 0.10, 'p50'].iloc[0], 1e-9) - 1) * 100))
|
||||
tick("§3")
|
||||
|
||||
# ================================= §4 ATTACCO 3 — la frontiera P(>=50/g) contro P(zero)
|
||||
hr("§4. ATTACCO 3 — LA FRONTIERA: P(>=50/g) e' una soglia sulla CODA DESTRA")
|
||||
POL = [("LIVE 75/25/0", W_LIVE), ("W_A 38/38/25 (racc.)", W_A),
|
||||
("38/25/38", {"TP01": 0.38, "SKH01": 0.25, "XS01": 0.38}),
|
||||
("argmaxJ 25/25/50", W_ARGMAX),
|
||||
("55/20/25 (book div 25/07)", {"TP01": 0.55, "SKH01": 0.20, "XS01": 0.25})]
|
||||
LEVS_FR = LEVS
|
||||
if time.time() - T0 > 0.45 * BUDGET_S:
|
||||
LEVS_FR = LEVS[::2]
|
||||
print(f" ⚠ BUDGET: leve della frontiera ridotte da {len(LEVS)} a {len(LEVS_FR)} "
|
||||
f"(dichiarato).")
|
||||
fr = []
|
||||
for nm, w in POL:
|
||||
fw = GC.fvec_for(w, I, rate, off_m, xs_ann)
|
||||
Rw, Gw = AP.rg_off(w, I, XSP[ph_m], off_m)
|
||||
Rw = Rw - fw
|
||||
for lv in LEVS_FR:
|
||||
lad = GC.ladder(Rw, Gw, N_LAD_FR, lv, SEED_LAD, refund=False)
|
||||
bump(1)
|
||||
fr.append(dict(pol=nm, lev=lv, p50=lad["p_target"], pz=lad["p_zero"],
|
||||
med=lad["med"], p10g=lad["p_ge10"]))
|
||||
F = pd.DataFrame(fr)
|
||||
rho = float(np.corrcoef(F["p50"], F["pz"])[0, 1])
|
||||
print(f" {len(POL)} politiche x {len(LEVS_FR)} leve = {len(F)} celle, cella d'ancora MEDIANA.")
|
||||
print(f"\n corr( P(>=50/g) , P(zero) ) sulle {len(F)} celle = **{rho:+.3f}** -> A4 "
|
||||
+ ("CONFERMATA" if rho > 0.5 else "REFUTATA"))
|
||||
b50 = F.loc[F["p50"].idxmax()]
|
||||
bz = F.loc[F["pz"].idxmin()]
|
||||
bmed = F.loc[F["med"].idxmax()]
|
||||
b10 = F.loc[F["p10g"].idxmax()]
|
||||
print(f"\n {'obiettivo massimizzato':>28} {'politica':>26} {'leva':>6} {'P(>=50/g)':>10} "
|
||||
f"{'P(zero)':>9} {'EUR/g med':>10}")
|
||||
for lab, r in (("P(>=50 EUR/g) <- il citato", b50), ("P(zero) minima", bz),
|
||||
("EUR/g mediana", bmed), ("P(>=10 EUR/g)", b10)):
|
||||
print(f" {lab:>28} {r['pol']:>26} {r['lev']:>6.2f} {r['p50']:>9.1%} "
|
||||
f"{r['pz']:>8.1%} {r['med']:>10.2f}")
|
||||
rec = F[(F["pol"] == "W_A 38/38/25 (racc.)")]
|
||||
rr = rec.loc[rec["p50"].idxmax()]
|
||||
print(f"\n LA RACCOMANDAZIONE ({rr['pol']} @ {rr['lev']:.2f}x): P(>=50/g) {rr['p50']:.1%}, "
|
||||
f"P(zero) {rr['pz']:.1%}, EUR/g {rr['med']:.2f}")
|
||||
dom = F[(F["p50"] >= rr["p50"]) & (F["pz"] <= rr["pz"]) &
|
||||
((F["p50"] > rr["p50"]) | (F["pz"] < rr["pz"]))]
|
||||
print(f" Celle che la DOMINANO (>= su P(>=50/g) e <= su P(zero)): **{len(dom)}** su {len(F)}")
|
||||
if len(dom):
|
||||
d0 = dom.loc[dom["p50"].idxmax()]
|
||||
print(f" la migliore: {d0['pol']} @ {d0['lev']:.2f}x -> {d0['p50']:.1%} / {d0['pz']:.1%}")
|
||||
# frontiera di Pareto
|
||||
pts = F.sort_values("pz")
|
||||
par, best = [], -1.0
|
||||
for _, r in pts.iterrows():
|
||||
if r["p50"] > best:
|
||||
par.append(r)
|
||||
best = r["p50"]
|
||||
P = pd.DataFrame(par)
|
||||
print(f"\n FRONTIERA DI PARETO ({len(P)} punti non dominati su {len(F)}):")
|
||||
print(f" {'P(zero)':>9} {'P(>=50/g)':>10} {'EUR/g med':>10} {'politica':>26} {'leva':>6}")
|
||||
for _, r in P.iterrows():
|
||||
star = " <== raccomandazione" if (r["pol"] == rr["pol"] and r["lev"] == rr["lev"]) else ""
|
||||
print(f" {r['pz']:>8.1%} {r['p50']:>9.1%} {r['med']:>10.2f} {r['pol']:>26} "
|
||||
f"{r['lev']:>6.2f}{star}")
|
||||
print("\n 📌 Il prezzo del punto scelto, in unita' comprensibili: passare dal punto a")
|
||||
print(" P(zero) minima a quello a P(>=50/g) massima costa "
|
||||
f"{(F['pz'].max()-F['pz'].min())*100:.0f}pp di probabilita' di finire a ZERO per "
|
||||
f"comprare {(F['p50'].max()-F['p50'].min())*100:.1f}pp di probabilita' di 50 EUR/g.")
|
||||
tick("§4")
|
||||
|
||||
# ============================== §5 ATTACCO 4 — il gate che il canale non ha mai passato
|
||||
hr("§5. ATTACCO 4 — IL NULL A DRIFT ZERO sulla griglia di 360 celle di PROP-ALLOC")
|
||||
grid = PA.simplex_grid(("TP01", "SKH01", "XS01"), STEP_SIMPLEX)
|
||||
n_cells = len(grid) * len(LEVS)
|
||||
print(f" Griglia di SELEZIONE dichiarata da PROP-ALLOC: {len(grid)} vettori di peso "
|
||||
f"(passo 1/{STEP_SIMPLEX}) x {len(LEVS)} leve = **{n_cells} celle**.")
|
||||
print(" Conteggio dei trial al RIALZO, come vuole il progetto: PROP-ALLOC 360 di selezione")
|
||||
print(" + la seconda firm (360) + PROP-RECAL su 3 finestre + le politiche del 25/07")
|
||||
print(" -> l'ordine di grandezza del multiple testing sul CANALE e' ~1.000-2.000 celle,")
|
||||
print(" e nessuno di questi filoni ha mai calcolato un deflated-Sharpe sul canale.")
|
||||
print("\n IL NULL: stesso pannello, stessa lente, stesse regole, stessa griglia — ma il")
|
||||
print(" DRIFT del libro azzerato (`R - mean(R)` per ogni vettore di peso). Domanda: quanto")
|
||||
print(" J estrae un argmax su 360 politiche quando NON c'e' edge? (Con drift zero si passa")
|
||||
print(" un'eval del +10% per pura varianza: il null NON e' zero.)")
|
||||
ev_n = PA.boot_idx(len(I), EV_H, N_NULL_J, seed=SEED_EV)
|
||||
fu_n = PA.boot_idx(len(I), FU_H, N_NULL_J, seed=SEED_FU)
|
||||
RG = {}
|
||||
for w in grid:
|
||||
key = PA.wkey(w)
|
||||
fw = GC.fvec_for(w, I, rate, off_m, xs_ann)
|
||||
Rw, Gw = AP.rg_off(w, I, XSP[ph_m], off_m)
|
||||
RG[key] = (Rw - fw, Gw)
|
||||
|
||||
def scan_grid(shift_to_zero: bool, ev_i, fu_i) -> np.ndarray:
|
||||
out = np.empty(n_cells)
|
||||
i = 0
|
||||
for w in grid:
|
||||
Rw, Gw = RG[PA.wkey(w)]
|
||||
Rz = Rw - Rw.mean() if shift_to_zero else Rw
|
||||
for lv in LEVS:
|
||||
out[i] = PR.obj_rg(Rz, Gw, lv, ev_i, fu_i, factor=DELUCK)["J"]
|
||||
i += 1
|
||||
bump(n_cells)
|
||||
return out
|
||||
|
||||
t = time.time()
|
||||
J_real = scan_grid(False, ev_n, fu_n)
|
||||
print(f"\n OSSERVATO ({time.time()-t:.0f}s): max-J su {n_cells} celle = **{J_real.max():.3f}** "
|
||||
f"| mediana {np.median(J_real):.3f} | p90 {np.percentile(J_real,90):.3f}")
|
||||
el = time.time() - T0
|
||||
per_scan = max(time.time() - t, 1.0)
|
||||
n_draws = N_NULL_DRAWS
|
||||
while n_draws > 2 and el + (n_draws + 1) * per_scan > BUDGET_S:
|
||||
n_draws -= 1
|
||||
if n_draws != N_NULL_DRAWS:
|
||||
print(f" ⚠ BUDGET: a {el:.0f}s con {per_scan:.0f}s a scansione, le estrazioni di null")
|
||||
print(f" scendono da {N_NULL_DRAWS} a {n_draws}. Dichiarato, non nascosto: la MEDIA")
|
||||
print(f" del max-J del null e' piu' rumorosa, la sua TAGLIA no.")
|
||||
nulls = []
|
||||
for b in range(n_draws):
|
||||
ev_i = PA.boot_idx(len(I), EV_H, N_NULL_J, seed=9000 + 2 * b)
|
||||
fu_i = PA.boot_idx(len(I), FU_H, N_NULL_J, seed=9001 + 2 * b)
|
||||
Jn = scan_grid(True, ev_i, fu_i)
|
||||
nulls.append(Jn)
|
||||
print(f" null #{b+1}: max-J {Jn.max():.3f} · mediana {np.median(Jn):.3f} "
|
||||
f"({time.time()-t:.0f}s)")
|
||||
N = np.vstack(nulls)
|
||||
nmax = N.max(axis=1)
|
||||
print(f"\n NULL A DRIFT ZERO ({n_draws} estrazioni, {N_NULL_J} percorsi ciascuna):")
|
||||
print(f" max-J atteso dal PURO RUMORE = **{nmax.mean():.3f}** "
|
||||
f"[min {nmax.min():.3f}, max {nmax.max():.3f}]")
|
||||
print(f" OSSERVATO {J_real.max():.3f} -> eccesso **{J_real.max()-nmax.mean():+.3f}** "
|
||||
f"({(J_real.max()/max(nmax.mean(),1e-9)-1)*100:+.0f}%)")
|
||||
print(f" estrazioni di null che BATTONO l'osservato: {int((nmax>=J_real.max()).sum())}"
|
||||
f"/{n_draws}")
|
||||
a5 = "CONFERMATA" if (0.25 <= nmax.mean() <= 0.45) else "REFUTATA"
|
||||
print(f" -> A5 (max-J del null fra 0,25 e 0,45) {a5}")
|
||||
# crescita del massimo col numero di celle: la sensibilita' del verdetto al CONTEGGIO
|
||||
print(f"\n Sensibilita' al CONTEGGIO dei trial (max-J del null su sottoinsiemi casuali):")
|
||||
rng = np.random.default_rng(4242)
|
||||
print(f" {'k celle':>9} {'max-J null':>11} {'osservato':>11} {'eccesso':>9}")
|
||||
for k in (45, 90, 180, 360):
|
||||
mk = np.array([N[b, rng.choice(n_cells, size=min(k, n_cells), replace=False)].max()
|
||||
for b in range(n_draws) for _ in range(4)])
|
||||
ok = np.array([J_real[rng.choice(n_cells, size=min(k, n_cells), replace=False)].max()
|
||||
for _ in range(20)]).mean()
|
||||
print(f" {k:>9} {mk.mean():>11.3f} {ok:>11.3f} {ok-mk.mean():>+9.3f}")
|
||||
# il gate STANDARD del progetto, puntato sul canale — e la sua CECITA' alla leva
|
||||
import altlib as AL # noqa: E402
|
||||
sh_w, ret_w = {}, {}
|
||||
for w in grid:
|
||||
Rw, Gw = RG[PA.wkey(w)]
|
||||
Rd = PA.deluck(Rw, DELUCK)
|
||||
v = float(Rd.std(ddof=1) * np.sqrt(365))
|
||||
sh_w[PA.wkey(w)] = float(Rd.mean() * 365 / v) if v > 0 else 0.0
|
||||
ret_w[PA.wkey(w)] = Rd
|
||||
kb = max(sh_w, key=sh_w.get)
|
||||
dsr, sr0 = AL.deflated_sharpe(sh_w[kb], list(sh_w.values()), ret_w[kb])
|
||||
print(f"\n IL GATE STANDARD, per confronto — `altlib.deflated_sharpe` sulla stessa griglia:")
|
||||
print(f" Sharpe migliore {sh_w[kb]:.3f} ({kb}) · attesa dal rumore su N={len(sh_w)} "
|
||||
f"trial {sr0:.3f} · **DSR {dsr:.3f} {'PASS' if dsr >= 0.95 else 'FAIL'}**")
|
||||
print(f" 🚨 Ma N e' **{len(sh_w)}, non {n_cells}**: lo Sharpe e' INVARIANTE ALLA LEVA")
|
||||
print(f" (`obj_rg` lo calcola su `Rd`, non su `Rd*lev`), quindi le {n_cells-len(sh_w)}")
|
||||
print(" celle che differiscono SOLO per la leva sono **invisibili** al gate standard.")
|
||||
print(" E' esattamente la lezione di §33/§53: la leva non la vede nessun gate del")
|
||||
print(" progetto. Su un conto a BARRIERA la leva e' la variabile che decide.")
|
||||
|
||||
# il libro LIVE, che NON e' stato selezionato, come incumbent
|
||||
fL = GC.fvec_for(W_LIVE, I, rate, off_m, xs_ann)
|
||||
RL, GL = AP.rg_off(W_LIVE, I, XSP[ph_m], off_m)
|
||||
jL_all = [PR.obj_rg(RL - fL, GL, lv, ev_n, fu_n, factor=DELUCK)["J"] for lv in LEVS]
|
||||
bump(len(LEVS))
|
||||
print(f"\n L'INCUMBENT (libro LIVE 75/25, che NON e' stato selezionato su questa griglia):")
|
||||
print(f" J max sulle 8 leve = {max(jL_all):.3f} -> anche l'incumbent "
|
||||
f"{'SUPERA' if max(jL_all) > nmax.mean() else 'NON supera'} il max del null.")
|
||||
print(" ⚠ CONTROLLO NEGATIVO obbligatorio: una estrazione di null trattata come se fosse")
|
||||
print(" il candidato deve dare eccesso ~0 contro le altre.")
|
||||
held = nmax[0]
|
||||
rest = nmax[1:]
|
||||
print(f" null #1 come candidato: max-J {held:.3f} contro media delle altre "
|
||||
f"{rest.mean():.3f} -> eccesso {held-rest.mean():+.3f} "
|
||||
f"({'OK, ~0' if abs(held-rest.mean()) < 0.05 else 'ATTENZIONE'})")
|
||||
print("\n 📌 Cosa dice e cosa NON dice: **non** dice che il canale sia rumore — l'eccesso")
|
||||
print(" e' misurato e positivo. Dice che **una parte non piccola del J pubblicato la")
|
||||
print(" produce la varianza attraverso una barriera**, e che nessuno l'aveva sottratta.")
|
||||
tick("§5")
|
||||
|
||||
# ================================================================== §6 il verdetto
|
||||
hr("§6. LA DOMANDA FINALE — se il canale funded fosse un CANDIDATO-SLEEVE, passerebbe?")
|
||||
ded = J_real.max() - nmax.mean()
|
||||
checks = [
|
||||
("edge in-sample (J > incumbent)", dj0 > 0.05,
|
||||
f"dJ {dj0:+.3f} contro il libro live"),
|
||||
("deflated / null di selezione", ded > 0.10,
|
||||
f"eccesso sul max del null a drift zero {ded:+.3f} su {n_cells} celle"),
|
||||
("robustezza al PARAMETRO (-1 SE)", dj_m1 > 0.05,
|
||||
f"dJ a -1 SE del drift di XS01 = {dj_m1:+.3f}"),
|
||||
("robustezza a -2 SE", dj_m2 > 0.05, f"dJ a -2 SE = {dj_m2:+.3f}"),
|
||||
("assunzione esogena stimata", (not np.isnan(p_be)) and p_be > p_hi,
|
||||
f"morte-firm: assunta {p_saved:.0%}, evidenza {p_lo:.0%}-{p_hi:.0%}, "
|
||||
f"break-even {p_be:.0%}" if not np.isnan(p_be) else
|
||||
f"morte-firm: assunta {p_saved:.0%}, evidenza {p_lo:.0%}-{p_hi:.0%}, break-even >55%"),
|
||||
("obiettivo non degenere", len(dom) == 0,
|
||||
f"{len(dom)} celle dominano la raccomandazione su (P(>=50/g), P(zero))"),
|
||||
("deflated-Sharpe standard (cieco alla leva)", dsr >= 0.95,
|
||||
f"DSR {dsr:.3f} su N={len(sh_w)} trial visibili di {n_cells} reali"),
|
||||
("fuori dalla finestra di scoperta", True,
|
||||
"§21: XS01 regge fuori campione (+1,12), MA a 13 gambe su 19 e a effetto/MDE ~1,0"),
|
||||
("eseguibilita' verificata al venue", True,
|
||||
"§30: 13/13 gambe `Trading` su Bybit, min notional $5 — PASS misurato"),
|
||||
]
|
||||
print(f" {'gate':>36} {'esito':>8} dettaglio")
|
||||
npass = 0
|
||||
for nm, ok, det in checks:
|
||||
npass += int(ok)
|
||||
print(f" {nm:>36} {'PASS' if ok else 'FAIL':>8} {det}")
|
||||
print(f"\n {npass}/{len(checks)} gate superati.")
|
||||
|
||||
hr("VERDETTO")
|
||||
print(f" 1. REPLICA: P(>=50 EUR/g) {m50:.1%} contro il pubblicato {PUB['p50g']:.1%}, "
|
||||
f"P(zero) {C['pz'].median():.1%} contro {PUB['pzero']:.1%} -> **la macchina e' quella**.")
|
||||
print(f" 2. IL PILASTRO: SE del drift di XS01 = {se_boot:.1%}/anno. A -1 SE il vantaggio "
|
||||
f"del canale passa da {dj0:+.3f} a {dj_m1:+.3f} di J e P(>=50/g) da {p50_0:.1%} a "
|
||||
f"{p50_m1:.1%}.")
|
||||
print(f" 3. LA MORTE-FIRM: evidenza pubblica {p_lo:.0%}-{p_hi:.0%}/anno contro il "
|
||||
f"{p_saved:.0%} assunto; l'EV regge (break-even "
|
||||
f"{'>' + f'{max(PS):.0%}' if np.isnan(p_be) else f'{p_be:.0%}'}), "
|
||||
f"ma P(>=50/g) scende a {p50_at_mid:.1%}.")
|
||||
print(f" 4. LA FRONTIERA: corr(P(>=50/g), P(zero)) = {rho:+.3f}; "
|
||||
f"{len(dom)} celle dominano il punto raccomandato.")
|
||||
print(f" 5. IL GATE MANCANTE: max-J dal puro rumore su {n_cells} celle = {nmax.mean():.3f}, "
|
||||
f"osservato {J_real.max():.3f}, eccesso {ded:+.3f}.")
|
||||
eur_pt = float(C["med"].median())
|
||||
eur_m1 = float(D[D["k"] == -1.0]["med"].median())
|
||||
eur_live = float(D[D["k"] == 0.0]["med_live"].median())
|
||||
print(f"\n IN EUR/GIORNO (mediana, 36 mesi, da 600 euro, funding e fisco dentro):")
|
||||
print(f" canale funded al drift misurato ... {eur_pt:>6.2f} EUR/g")
|
||||
print(f" canale funded a -1 SE ............ {eur_m1:>6.2f} EUR/g")
|
||||
print(f" libro LIVE sullo stesso conto .... {eur_live:>6.2f} EUR/g")
|
||||
print(f" obiettivo dichiarato ............. {pl.TARGET_EUR_DAY:>6.2f} EUR/g")
|
||||
print(f"\n Questo filone NON avvicina i 50 EUR/giorno: non produce ritorno, "
|
||||
f"riduce la fiducia")
|
||||
print(f" nel numero gia' pubblicato. Il suo effetto sulla rendita attesa e' "
|
||||
f"**{eur_m1-eur_pt:+.2f} EUR/g**")
|
||||
print(f" se si crede a -1 SE, e **0,00 EUR/g** se non si cambia nulla (ed e' cio' che "
|
||||
f"raccomanda).")
|
||||
print(f"\n [{TRIALS} valutazioni, {time.time()-T0:.0f}s]")
|
||||
print("=" * 104)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,784 @@
|
||||
"""r0823b_split_deposito — §62 SPLIT-DEPOSITO: quanta parte del versamento va ai BIGLIETTI (2026-08-23).
|
||||
|
||||
IL BUCO CHE CHIUDE
|
||||
------------------
|
||||
`RESULTS-0822 §37` (GATE-C) ha confrontato **due strade INTERE** — tutto sul libro contro tutto in
|
||||
biglietti prop — e il biglietto ha vinto a EUR 500/mese (mediana $39.820 contro $22.444,
|
||||
P(>=50/g) 13,7% contro 0,0%). Ma **«tutto o niente» non e' una politica: e' un caso limite.**
|
||||
Nessuno ha misurato (a) la FRAZIONE ottima del versamento, (b) se debba CAMBIARE nel tempo,
|
||||
(c) su quale colonna si sta ottimizzando — e le colonne hanno ottimi diversi.
|
||||
|
||||
LE MIE ATTESE, REGISTRATE PRIMA DI MISURARE (metodo obbligatorio, punto 1)
|
||||
-------------------------------------------------------------------------
|
||||
A1. **La forma della politica ottima, PREVISTA dalla struttura** (mandato punto 4). I due canali
|
||||
hanno rendimenti di scala OPPOSTI:
|
||||
* il LIBRO e' *neutrale alla scala* — Sharpe piatto da $600 a $200k (25/07 §3), quindi
|
||||
ogni dollaro rende la stessa percentuale: la ricchezza e' LINEARE nel capitale versato;
|
||||
* il BIGLIETTO ha rendimenti di scala **DECRESCENTI e a gradini**: il prezzo e' FISSO
|
||||
($249-$1.080) e il nozionale che sblocca e' FISSO ($25k-$200k) — **indipendente dal
|
||||
proprio capitale**; sotto $249 un dollaro in piu' non fa nulla, e sopra il cap
|
||||
($200k/firm, 6 slot concorrenti) nemmeno.
|
||||
⇒ **PREVISIONE: la politica ottima e' FRONT-LOADED e SATURANTE** — biglietti prima (quando il
|
||||
libro ha una base di capitalizzazione ridicola e un biglietto sblocca 150x il conto), libro
|
||||
dopo (quando il canale biglietto e' saturo). Cioe': `TIXFIRST` batte `BOOKFIRST`, e phi
|
||||
DECRESCENTE col capitale batte phi CRESCENTE.
|
||||
A2. **Gli ottimi delle tre colonne NON coincidono**: P(>=50/g) crescente in phi con argmax a
|
||||
phi=1 (a 36-60 mesi **solo** il canale biglietto puo' produrre un prelievo); ricchezza
|
||||
MEDIANA con argmax a phi BASSO (la strada-biglietto e' bimodale, §37); P(rovina) crescente
|
||||
in phi. **Se e' cosi', «la frazione ottima» non esiste finche' non si dice quale colonna.**
|
||||
A3. **A 60 mesi l'ottimo phi SCENDE**: la morte-firm 10%/anno rende il canale biglietto un canale
|
||||
a VITA FINITA (P(entrambe le firm morte a 5 anni) ~17%), mentre il libro capitalizza per
|
||||
sempre. E' l'unica ragione strutturale per cui l'orizzonte dovrebbe muovere l'ottimo.
|
||||
A4. **Il trabocchetto §44 si eredita, e con lo stesso segno**: mettere una CONDIZIONE RARA davanti
|
||||
all'acquisto di un biglietto costa, perche' ritarda le giocate di una lotteria ripetuta.
|
||||
Mi aspetto un costo **proporzionale al tempo d'attesa**, come in §44 — e lo misuro contro un
|
||||
**gemello a ritardo deterministico** di pari attesa media, che e' il modo per separare il
|
||||
costo della CONDIZIONE da quello del RITARDO.
|
||||
A5. **La riga onesta**: mi aspetto che l'ampiezza dovuta alla frazione sia GRANDE sulla colonna
|
||||
P(>=50/g) — ma solo perche' il libro vale ZERO su quella colonna a questo orizzonte (non e'
|
||||
un difetto del libro, e' l'orizzonte: servono $313k) — e PICCOLA sulla colonna che misura la
|
||||
ricchezza. Se esce cosi', va detto che **la frazione conta sulla metrica sbagliata**.
|
||||
|
||||
LA FAMIGLIA, DICHIARATA PRIMA DI MISURARE (mandato punto 3)
|
||||
-----------------------------------------------------------
|
||||
F(phi) frazione FISSA del versamento ai biglietti, phi = 0,00 ... 1,00 (11 celle).
|
||||
phi=1 == la strada BIGLIETTO di §37; phi=0 == la strada LIBRO di §37.
|
||||
TIX(X) **biglietti prima**: phi=1 finche' il cumulato versato ai biglietti < $X,
|
||||
poi phi=0. X = 700 (= solo il capitale iniziale = "biglietti solo dai payout",
|
||||
perche' i payout tornano sempre nel pot biglietti), 2.000, 5.000, 10.000.
|
||||
BOOK(X) **libro prima**: phi=0 finche' il libro < $X, poi phi=1. X = 2.000, 5.000,
|
||||
10.000, 20.000.
|
||||
PHI_UP(X) phi CRESCE col capitale: phi = clip(libro / X, 0, 1), X = 10.000.
|
||||
PHI_DN(X) phi DECRESCE col capitale: phi = 1 - clip(libro / X, 0, 1), X = 10.000.
|
||||
CASH(B) phi=1 ma la cassa in eccesso oltre $B va al libro (B = 1.200 = il biglietto piu'
|
||||
caro). E' l'unica politica che puo' DOMINARE phi=1 per costruzione.
|
||||
RARE(d) phi=1 ma si COMPRA solo dopo un drawdown >= d dell'equity della strategia
|
||||
(d = 10%, 20%): il trabocchetto §44 applicato al biglietto.
|
||||
DELAY(g) phi=1 ma non si compra prima del giorno g: **gemello deterministico** di RARE.
|
||||
Il capitale iniziale ($654) e' trattato come il "versamento del mese 0" e segue la stessa regola.
|
||||
|
||||
CONVENZIONI EREDITATE E CONGELATE (nessuna scelta nuova => nessun trial da deflazionare)
|
||||
-----------------------------------------------------------------------------------------
|
||||
* Simulatore biglietti: copia di `r0822d_gate_c.ladder` (che e' bit-exact vs `r0725_prop_coupled.
|
||||
simulate`) con l'aggiunta del pot LIBRO. Lente **ACCOPPIATA** (tuple (R, gap) del recon): su una
|
||||
regola a UN GIORNO la close-only e' esattamente CIECA (25/07).
|
||||
* Conto funded: W_A = TP01 38 / SKH01 38 / XS01 25 (centro della regione robusta di PROP-RECAL),
|
||||
XS01 = U13 Binance, finestra W-LONG 2021+, **funding DENTRO**, de-luck sul drift **x0,89**.
|
||||
* Pot LIBRO: `FD.book_75_25(rate, alloc=654)` = libro LIVE 75/25 con min-order $5 e funding
|
||||
dentro, de-luck x0,89, fisco 33% sulla variazione annua con riporto (convenzione di
|
||||
`r0822d_gate_c.book_road` = quella di `r0807_piano_netto`). ⚠ Dichiarato: NON contiene la
|
||||
patrimoniale 0,2%/anno che `PN.accumula` invece include; la differenza e' misurata in §1.
|
||||
* Morte-firm 10%/anno, cap $200k/firm, 6 slot, deposito **rimborsato al primo payout** (§37),
|
||||
soglia di prelievo $100 di quota trader, fisco 33% sui payout, EUR/USD 1,09.
|
||||
* Rendita: `perp` e muro dalla lente **L3 CONGIUNTA** (`PN.muro`), cioe' la stessa che produce i
|
||||
$313k del piano.
|
||||
|
||||
Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_split_deposito.py`
|
||||
Rete: NESSUNA (`--no-net` forzato: parquet certificati + cache Binance/funding gia' su disco).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"):
|
||||
sys.path.insert(0, str(_p))
|
||||
|
||||
if "--no-net" not in sys.argv: # r0822d_funding legge USE_NET all'import
|
||||
sys.argv.append("--no-net")
|
||||
|
||||
import r0725_prop_coupled as pc # noqa: E402 lente accoppiata (25/07)
|
||||
import r0725_prop_ladder as pl # noqa: E402 regole firm + scala di conti (25/07)
|
||||
import r0807_piano_netto as PN # noqa: E402 muro / accumula (07/08)
|
||||
import r0727_tasse as TX # noqa: E402 patrimoniale
|
||||
import r0822_prop_alloc as PA # noqa: E402 J, bootstrap (22/08)
|
||||
import r0822b_prop_recal as PR # noqa: E402 PROP-RECAL (22/08)
|
||||
import r0822b_xs01_oos as X # noqa: E402 universo U13 + cache Binance
|
||||
import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01
|
||||
import r0822d_funding as FD # noqa: E402 il funding (22/08)
|
||||
import r0822d_gate_c as GC # noqa: E402 §37: ladder + book_road
|
||||
from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402
|
||||
|
||||
FD.USE_NET = False
|
||||
|
||||
EURUSD = pl.EURUSD
|
||||
TAX_RATE = pl.TAX_RATE
|
||||
SPLIT = pl.SPLIT
|
||||
DELUCK = PA.DELUCK # x0,89 MISURATO (r0726_deluck_factor)
|
||||
FIRMS = pl.FIRMS
|
||||
N_SLOT = pl.MAX_CONCURRENT
|
||||
TARGET = pl.TARGET_EUR_DAY
|
||||
START_EUR = 600.0 # $654 = il conto reale (convenzione di §37)
|
||||
MIN_PAYOUT = GC.MIN_PAYOUT_TRADER # $100 di quota trader
|
||||
BLOCK = 20
|
||||
SEED = 20260823
|
||||
N_BASE = 1500 # risoluzione dichiarata: ~+-1pp su P(>=50/g)
|
||||
DEP_MAIN = 500.0 # il piano in corso (config/live.json, 26/07)
|
||||
CHEAP = min(t[1] for F in FIRMS for t in F["tickets"]) # $249
|
||||
|
||||
# celle d'ancora: sotto-campione SISTEMATICO dichiarato a priori sui 23 offset x 3 fasi di §32
|
||||
CELLS = ((0, 0), (150, 3), (300, 7), (450, 0), (600, 3))
|
||||
|
||||
# numeri PUBBLICATI da riprodurre prima di produrne di nuovi
|
||||
PUB = dict(muro=313_000.0, p50g_37=0.137, med_tix_37=39_820.0, med_book_37=22_444.0,
|
||||
med_tix_0=132.0, med_book_0=787.0, p50g_0=0.042, pzero_37=0.403, p50g_anchor=0.026)
|
||||
|
||||
T0 = time.time()
|
||||
|
||||
|
||||
def clock() -> str:
|
||||
return f"[{time.time()-T0:5.0f}s]"
|
||||
|
||||
|
||||
def hr(t: str = "") -> None:
|
||||
print("\n" + "=" * 108)
|
||||
if t:
|
||||
print(f" {t}")
|
||||
print("=" * 108)
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# LE POLITICHE — (etichetta, tipo, parametro). Dichiarate sopra, nel docstring.
|
||||
# ===========================================================================================
|
||||
def phi_of(kind: str, par: float, book: np.ndarray, cash: np.ndarray,
|
||||
to_tix: np.ndarray) -> np.ndarray:
|
||||
"""Frazione del versamento che va al pot BIGLIETTI. Vettoriale sul blocco di percorsi."""
|
||||
if kind == "FIX":
|
||||
return np.full(len(book), float(par))
|
||||
if kind == "TIX": # biglietti prima
|
||||
return (to_tix < par).astype(float)
|
||||
if kind == "BOOK": # libro prima
|
||||
return (book >= par).astype(float)
|
||||
if kind == "PHI_UP": # cresce col capitale
|
||||
return np.clip(book / par, 0.0, 1.0)
|
||||
if kind == "PHI_DN": # decresce col capitale
|
||||
return 1.0 - np.clip(book / par, 0.0, 1.0)
|
||||
if kind in ("CASH", "RARE", "DELAY"): # phi = 1, la differenza e' altrove
|
||||
return np.ones(len(book))
|
||||
raise ValueError(kind)
|
||||
|
||||
|
||||
def make_policies(full: bool = True) -> list[tuple[str, str, float]]:
|
||||
P: list[tuple[str, str, float]] = []
|
||||
grid = np.round(np.arange(0.0, 1.001, 0.10), 2) if full else np.array([0.0, 0.25, 0.50, 0.75, 1.0])
|
||||
for f in grid:
|
||||
P.append((f"F {f:.2f}", "FIX", float(f)))
|
||||
if not full:
|
||||
return P
|
||||
for xk in (700.0, 2_000.0, 5_000.0, 10_000.0):
|
||||
P.append((f"TIX ${xk:,.0f}", "TIX", xk))
|
||||
for xk in (2_000.0, 5_000.0, 10_000.0, 20_000.0):
|
||||
P.append((f"BOOK ${xk:,.0f}", "BOOK", xk))
|
||||
P.append(("PHI_UP $10k", "PHI_UP", 10_000.0))
|
||||
P.append(("PHI_DN $10k", "PHI_DN", 10_000.0))
|
||||
P.append(("CASH-ATT $1.2k", "CASH", 1_200.0))
|
||||
P.append(("RARE dd 10%", "RARE", 0.10))
|
||||
P.append(("RARE dd 20%", "RARE", 0.20))
|
||||
P.append(("DELAY 95g", "DELAY", 95.0))
|
||||
P.append(("DELAY 713g", "DELAY", 713.0))
|
||||
return P
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# IL SIMULATORE COMBINATO — pot BIGLIETTI + pot LIBRO sullo STESSO percorso
|
||||
# ===========================================================================================
|
||||
def sim_split(R: np.ndarray, G: np.ndarray, rb: np.ndarray, pols: list, n_base: int,
|
||||
lev: float, seed: int, n_days: int, deposit_eur: float = DEP_MAIN,
|
||||
start_eur: float = START_EUR, refund: bool = True,
|
||||
min_payout: float = MIN_PAYOUT, deluck: float = DELUCK,
|
||||
block: int = BLOCK, tax: float = TAX_RATE) -> dict:
|
||||
"""Estende `r0822d_gate_c.ladder` con un secondo pot (il LIBRO) e con una politica di SPLIT
|
||||
del versamento mensile. Le politiche sono impilate come BLOCCHI DI PERCORSI: stesso
|
||||
bootstrap, stessa morte-firm (tilata), stesso ordine di estrazione => **confronto APPAIATO
|
||||
perfetto** fra politiche.
|
||||
|
||||
Con `pols=[("x","FIX",1.0)]`, `refund=False`, `deposit=0`, `min_payout=0` dev'essere
|
||||
BIT-EXACT rispetto a `GC.ladder` (controllo R2). Con `pols=[("x","FIX",0.0)]` il pot libro
|
||||
dev'essere BIT-EXACT rispetto a `GC.book_road` (controllo R3).
|
||||
"""
|
||||
n_pol = len(pols)
|
||||
P = n_pol * n_base
|
||||
L = len(R)
|
||||
rng = np.random.default_rng(seed)
|
||||
|
||||
Rd = R.astype(float) - (1.0 - deluck) * float(R.astype(float).mean())
|
||||
Gd = G.astype(float)
|
||||
Bd = rb.astype(float) - (1.0 - deluck) * float(rb.astype(float).mean())
|
||||
|
||||
n_blocks = int(np.ceil(n_days / block))
|
||||
starts0 = rng.integers(0, L - block, size=(n_base, n_blocks)) # stesso stream di GC
|
||||
starts = np.tile(starts0, (n_pol, 1)) # ...e TILATO: appaiato
|
||||
deaths0 = rng.random((n_days, n_base, len(FIRMS))) # morte-firm, tilata
|
||||
p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0)
|
||||
|
||||
pid = np.repeat(np.arange(n_pol), n_base)
|
||||
sl = [slice(p * n_base, (p + 1) * n_base) for p in range(n_pol)]
|
||||
kinds = [k for _, k, _ in pols]
|
||||
pars = [float(v) for _, _, v in pols]
|
||||
|
||||
# --- stato pot BIGLIETTI (identico a GC.ladder) ---------------------------------------
|
||||
cash = np.zeros(P)
|
||||
phase = np.full((P, N_SLOT), -1, np.int8)
|
||||
eq = np.ones((P, N_SLOT))
|
||||
firm = np.full((P, N_SLOT), -1, np.int8)
|
||||
notional = np.zeros((P, N_SLOT))
|
||||
price_paid = np.zeros((P, N_SLOT))
|
||||
refunded = np.zeros((P, N_SLOT), bool)
|
||||
firm_alive = np.ones((P, len(FIRMS)), bool)
|
||||
used_f = np.zeros((P, len(FIRMS))) # nozionale aperto per firm, mantenuto INCREMENTALE
|
||||
cum_payout = np.zeros(P)
|
||||
spent = np.zeros(P)
|
||||
got_back = np.zeros(P)
|
||||
n_payouts = np.zeros(P, int)
|
||||
n_bought = np.zeros(P, int)
|
||||
to_tix = np.zeros(P) # cumulato VERSATO al pot biglietti (non i payout)
|
||||
to_book = np.zeros(P)
|
||||
# --- stato pot LIBRO (identico a GC.book_road) ----------------------------------------
|
||||
bookc = np.zeros(P)
|
||||
basis = np.zeros(P)
|
||||
carry = np.zeros(P)
|
||||
# --- equity della strategia (per la condizione RARE): osservabile, indipendente dal pot -
|
||||
eqs = np.ones(P)
|
||||
peak = np.ones(P)
|
||||
|
||||
def deposita(amount: np.ndarray) -> None:
|
||||
"""Ripartisce `amount` (per percorso) fra i due pot secondo la politica del blocco."""
|
||||
for p in range(n_pol):
|
||||
s = sl[p]
|
||||
f = phi_of(kinds[p], pars[p], bookc[s], cash[s], to_tix[s])
|
||||
a = amount[s]
|
||||
cash[s] += f * a
|
||||
to_tix[s] += f * a
|
||||
bookc[s] += (1.0 - f) * a
|
||||
basis[s] += (1.0 - f) * a
|
||||
to_book[s] += (1.0 - f) * a
|
||||
|
||||
deposita(np.full(P, start_eur * EURUSD)) # il capitale iniziale = "mese 0"
|
||||
|
||||
for t in range(n_days):
|
||||
di = starts[:, t // block] + (t % block)
|
||||
r_col = Rd[di] * lev
|
||||
g_col = Gd[di] * lev
|
||||
rb_t = Bd[di]
|
||||
|
||||
d_t = np.tile(deaths0[t], (n_pol, 1)) < p_death_day
|
||||
newly_dead = d_t & firm_alive
|
||||
firm_alive &= ~d_t
|
||||
if newly_dead.any():
|
||||
for fi in range(len(FIRMS)):
|
||||
kill = newly_dead[:, fi]
|
||||
if kill.any():
|
||||
hit = (firm == fi) & kill[:, None]
|
||||
phase[hit] = -1
|
||||
notional[hit] = 0.0
|
||||
used_f[kill, fi] = 0.0
|
||||
|
||||
# --- gating dell'acquisto: default aperto, chiuso per RARE/DELAY ------------------
|
||||
allow = np.ones(P, bool)
|
||||
for p in range(n_pol):
|
||||
if kinds[p] == "RARE":
|
||||
allow[sl[p]] = (eqs[sl[p]] / peak[sl[p]] - 1.0) <= -pars[p]
|
||||
elif kinds[p] == "DELAY":
|
||||
allow[sl[p]] = t >= pars[p]
|
||||
|
||||
# --- acquisto biglietti (ordine identico a GC.ladder) ----------------------------
|
||||
for k in range(N_SLOT):
|
||||
free = (phase[:, k] == -1) & allow
|
||||
if not free.any():
|
||||
continue
|
||||
for fi, F in enumerate(FIRMS):
|
||||
used = used_f[:, fi] # vista: si aggiorna da sola sotto
|
||||
for (size, price) in sorted(F["tickets"], key=lambda x: -x[0]):
|
||||
buy = (free & firm_alive[:, fi] & (cash >= price)
|
||||
& (used + size <= F["cap"]))
|
||||
if not buy.any():
|
||||
continue
|
||||
cash[buy] -= price
|
||||
spent[buy] += price
|
||||
n_bought[buy] += 1
|
||||
phase[buy, k] = 0
|
||||
eq[buy, k] = 1.0
|
||||
firm[buy, k] = fi
|
||||
notional[buy, k] = size
|
||||
price_paid[buy, k] = price
|
||||
refunded[buy, k] = False
|
||||
used_f[buy, fi] += size
|
||||
free = free & ~buy
|
||||
if not free.any():
|
||||
break
|
||||
if not free.any():
|
||||
break
|
||||
|
||||
# --- il giorno di mercato ---------------------------------------------------------
|
||||
r = r_col[:, None]
|
||||
g = g_col[:, None]
|
||||
act = phase >= 0
|
||||
eq_prev = eq
|
||||
eq = np.where(act, eq * (1.0 + r), eq)
|
||||
eq_low = np.where(act, eq_prev * (1.0 + r + g), eq)
|
||||
r_low = r + g
|
||||
|
||||
for fi, F in enumerate(FIRMS):
|
||||
s_ = act & (firm == fi)
|
||||
if not s_.any():
|
||||
continue
|
||||
ev_t, ev_dd, ev_dl = F["ev"]
|
||||
fu_ml, fu_dl = F["fu"]
|
||||
in_ev = s_ & (phase == 0)
|
||||
in_fu = s_ & (phase == 1)
|
||||
bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl)))
|
||||
| (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl))))
|
||||
if bust.any():
|
||||
used_f[:, fi] -= np.where(bust, notional, 0.0).sum(axis=1)
|
||||
phase[bust] = -1
|
||||
notional[bust] = 0.0
|
||||
passed = in_ev & (eq >= 1.0 + ev_t) & ~bust
|
||||
phase[passed] = 1
|
||||
eq[passed] = 1.0
|
||||
|
||||
# --- il pot LIBRO + l'equity osservabile della strategia --------------------------
|
||||
bookc = np.maximum(bookc * (1.0 + rb_t), 0.0)
|
||||
eqs = eqs * (1.0 + rb_t)
|
||||
peak = np.maximum(peak, eqs)
|
||||
|
||||
# --- fine mese: payout, rimborso, cassa attiva, versamento ------------------------
|
||||
if (t + 1) % 30 == 0:
|
||||
fu = phase == 1
|
||||
pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout)
|
||||
gain = np.where(pay, (eq - 1.0) * notional, 0.0)
|
||||
net = gain.sum(axis=1) * SPLIT * (1.0 - tax)
|
||||
cum_payout += net
|
||||
cash += net
|
||||
n_payouts += (pay.sum(axis=1) > 0).astype(int)
|
||||
eq = np.where(pay, 1.0, eq)
|
||||
if refund:
|
||||
back = pay & ~refunded
|
||||
amt = np.where(back, price_paid, 0.0).sum(axis=1)
|
||||
cash += amt
|
||||
got_back += amt
|
||||
refunded |= back
|
||||
for p in range(n_pol): # CASH-ATT: eccesso di cassa al libro
|
||||
if kinds[p] == "CASH":
|
||||
s = sl[p]
|
||||
ex = np.maximum(cash[s] - pars[p], 0.0)
|
||||
cash[s] -= ex
|
||||
bookc[s] += ex
|
||||
basis[s] += ex
|
||||
if deposit_eur:
|
||||
deposita(np.full(P, deposit_eur * EURUSD))
|
||||
|
||||
# --- fine anno: fisco sul pot LIBRO (convenzione GC.book_road) --------------------
|
||||
if (t + 1) % 365 == 0:
|
||||
gg = (bookc - basis) + carry
|
||||
due = np.where(gg > 0, tax * gg, 0.0)
|
||||
carry = np.where(gg > 0, 0.0, gg)
|
||||
bookc = bookc - due
|
||||
basis = bookc.copy()
|
||||
|
||||
years = n_days / 365.0
|
||||
flow = cum_payout / EURUSD / years / 365.0
|
||||
wealth = cash + bookc
|
||||
contributed = start_eur * EURUSD + deposit_eur * EURUSD * (n_days // 30)
|
||||
out = []
|
||||
for p, (lab, kind, par) in enumerate(pols):
|
||||
s = sl[p]
|
||||
out.append(dict(
|
||||
lab=lab, kind=kind, par=par,
|
||||
flow=flow[s], wealth=wealth[s], cash=cash[s], book=bookc[s],
|
||||
payout=cum_payout[s], spent=spent[s], back=got_back[s],
|
||||
to_tix=to_tix[s], to_book=to_book[s], nbuy=n_bought[s],
|
||||
npay=n_payouts[s], contributed=contributed))
|
||||
return dict(rows=out, contributed=contributed, years=years)
|
||||
|
||||
|
||||
def summ(d: dict, perp: float) -> dict:
|
||||
"""Le colonne che si leggono. `rend` = ricchezza terminale x rendita perpetua (la
|
||||
definizione di EUR 50/giorno del PIANO); `flow` = payout medi (la definizione di §37)."""
|
||||
w, f = d["wealth"], d["flow"]
|
||||
rend = w * perp / 365.0 / EURUSD
|
||||
return dict(
|
||||
lab=d["lab"],
|
||||
p50_flow=float((f >= TARGET).mean()),
|
||||
p50_rend=float((rend >= TARGET).mean()),
|
||||
med_w=float(np.median(w)), mean_w=float(w.mean()),
|
||||
p10_w=float(np.percentile(w, 10)), p90_w=float(np.percentile(w, 90)),
|
||||
med_flow=float(np.median(f)), med_rend=float(np.median(rend)),
|
||||
p_loss=float((w < d["contributed"]).mean()),
|
||||
p_ruin=float((w < CHEAP).mean()),
|
||||
p_nopay=float((d["payout"] <= 0).mean()),
|
||||
med_tix=float(np.median(d["to_tix"])), nbuy=float(np.mean(d["nbuy"])))
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
def main() -> None:
|
||||
try:
|
||||
sys.stdout.reconfigure(line_buffering=True)
|
||||
except Exception: # pragma: no cover
|
||||
pass
|
||||
hr("§62 SPLIT-DEPOSITO — quanta parte del versamento mensile va ai BIGLIETTI prop?")
|
||||
print(" §37 ha confrontato due CASI LIMITE (tutto libro / tutto biglietti). Qui si misura la")
|
||||
print(" CURVA, e se la frazione debba dipendere dallo stato. Attese registrate nel docstring:")
|
||||
print(" A1 politica ottima FRONT-LOADED e saturante (TIX batte BOOK, phi decrescente batte")
|
||||
print(" crescente), perche' il libro e' neutrale alla scala e il biglietto ha rendimenti")
|
||||
print(" DECRESCENTI a gradini (prezzo fisso, nozionale fisso, cap, indivisibilita');")
|
||||
print(" A2 gli ottimi delle tre colonne NON coincidono; A3 a 60 mesi l'ottimo phi SCENDE;")
|
||||
print(" A4 il trabocchetto §44 si eredita col segno negativo; A5 la frazione conta molto")
|
||||
print(" su P(>=50/g) solo perche' il libro vale ZERO su quella colonna a 36-60 mesi.")
|
||||
|
||||
# ================================================================= dati
|
||||
hr(f"§0. IL PANNELLO — le stesse serie di §37 (U13 Binance, W-LONG 2021+) {clock()}")
|
||||
Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE)
|
||||
p13 = Cb[X.U13].dropna()
|
||||
o13, h13, l13 = (Ob.reindex(p13.index)[X.U13], Hb.reindex(p13.index)[X.U13],
|
||||
Lb.reindex(p13.index)[X.U13])
|
||||
phases = sorted({ph for _, ph in CELLS})
|
||||
XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in phases}
|
||||
xs0 = XSP[0]
|
||||
base = pc.crypto_daily_tuples(1.0, 0.0).index.intersection(xs0.index)
|
||||
first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]]
|
||||
I = base[base >= max(first13, pd.Timestamp("2021-01-01", tz="UTC"))]
|
||||
print(f" W-LONG: {len(I)} giorni {I[0].date()} -> {I[-1].date()} | de-luck x{DELUCK}")
|
||||
|
||||
rate = GC.funding_rate()
|
||||
if rate is None:
|
||||
print(" !! cache funding assente: il filone NON gira senza funding (lente L3). STOP.")
|
||||
return
|
||||
xs_ann = GC.xs_funding_measure(verbose=False)["ann"]
|
||||
print(f" funding: cache OK | XS01 paga {xs_ann*100:+.2f}%/anno (riproduzione di §37)")
|
||||
|
||||
rb_full = FD.book_75_25(rate, alloc=654.0)
|
||||
if rb_full.index.tz is None:
|
||||
rb_full.index = rb_full.index.tz_localize("UTC")
|
||||
rb = np.nan_to_num(rb_full.reindex(I).values.astype(float))
|
||||
print(f" pot LIBRO (75/25 a $654, funding dentro): drift {rb.mean()*365*100:.2f}%/anno, "
|
||||
f"vol {rb.std()*np.sqrt(365)*100:.1f}%, Sharpe {rb.mean()*365/(rb.std()*np.sqrt(365)):.2f}")
|
||||
|
||||
W_A = {"TP01": 0.38, "SKH01": 0.38, "XS01": 0.25}
|
||||
ev_b = PA.boot_idx(len(I), 365, PA.N_PATHS, seed=8220)
|
||||
fu_b = PA.boot_idx(len(I), 365, PA.N_PATHS, seed=8221)
|
||||
RG: dict = {}
|
||||
for off, ph in CELLS:
|
||||
f = GC.fvec_for(W_A, I, rate, off, xs_ann)
|
||||
R0, G0 = AP.rg_off(W_A, I, XSP[ph], off)
|
||||
Rx = R0 - f
|
||||
j, lv, _ = GC.best_lev(Rx, G0, ev_b, fu_b)
|
||||
RG[(off, ph)] = (Rx, G0, lv, j)
|
||||
print(f"\n {len(CELLS)} celle d'ancora (sotto-campione sistematico a priori sui 23 offset x "
|
||||
f"3 fasi di §32):")
|
||||
for (off, ph), (Rx, _, lv, j) in RG.items():
|
||||
print(f" offset {off:>3} min, fase {ph} -> J {j:.3f} @ leva {lv:.3f}x "
|
||||
f"drift {Rx.mean()*365*100:+6.2f}%/anno")
|
||||
|
||||
# ================================================================= §1 repliche
|
||||
hr(f"§1. LE REPLICHE — prima di produrre un numero nuovo {clock()}")
|
||||
ok: dict[str, bool] = {}
|
||||
|
||||
# R1: muro L3 (la rendita perpetua che converte capitale in EUR/giorno)
|
||||
import r0822d_piano_vero as PV # noqa: E402
|
||||
B3 = PV.costruisci_serie()
|
||||
r_l3 = PV.deluck(B3["fund"].values.astype(float))
|
||||
netto = TARGET * 365 * EURUSD
|
||||
perp, muro = PN.muro(r_l3, netto, TAX_RATE, TX.PATRIMONIALE)
|
||||
ok["R1"] = abs(muro - PUB["muro"]) < 3_000.0
|
||||
print(f" R1 muro L3 CONGIUNTA: perpetua {perp:.2%} · ${muro:,.0f} pubblicato $313k"
|
||||
f" {'OK' if ok['R1'] else 'DIVERGE'}")
|
||||
print(f" (il pot LIBRO di questo filone gira su `alloc=654` invece del default "
|
||||
f"`alloc={FD.ALLOC:.0f}` di L3: drift "
|
||||
f"{rb.mean()*365*100:.2f}% contro {PV.deluck(B3['fund'].values.astype(float)).mean()*365*100:.2f}% "
|
||||
f"-> differenza dichiarata, non nascosta)")
|
||||
|
||||
# R2: il mio simulatore == GC.ladder (che e' bit-exact vs pc.simulate)
|
||||
cell0 = CELLS[0]
|
||||
R0, G0, LV0, _ = RG[cell0]
|
||||
ref = GC.ladder(R0, G0, N_BASE, LV0, SEED, refund=False, min_payout=0.0, deposit_eur=0.0)
|
||||
mine = sim_split(R0, G0, rb, [("ctl", "FIX", 1.0)], N_BASE, LV0, SEED, 1080,
|
||||
deposit_eur=0.0, refund=False, min_payout=0.0)
|
||||
a = np.sort(ref["eur_day"])
|
||||
b = np.sort(mine["rows"][0]["flow"])
|
||||
d2 = float(np.abs(ref["eur_day"] - mine["rows"][0]["flow"]).max())
|
||||
ok["R2"] = d2 < 1e-12
|
||||
print(f" R2 sim_split(phi=1) vs GC.ladder, percorso per percorso: max|diff| = {d2:.3e}"
|
||||
f" {'BIT-EXACT' if ok['R2'] else 'DIVERGE'} (ordinati {np.abs(a-b).max():.3e})")
|
||||
|
||||
# R3: il pot libro == GC.book_road, sugli stessi sorteggi
|
||||
n_blocks = int(np.ceil(1080 / BLOCK))
|
||||
rng_c = np.random.default_rng(SEED)
|
||||
st_c = rng_c.integers(0, len(I) - BLOCK, size=(N_BASE, n_blocks))
|
||||
BOOT_C = (st_c[:, :, None] + np.arange(BLOCK)[None, None, :]).reshape(N_BASE, -1)[:, :1080]
|
||||
brd = GC.book_road(rb, BOOT_C, START_EUR, DEP_MAIN)
|
||||
mineb = sim_split(R0, G0, rb, [("ctl", "FIX", 0.0)], N_BASE, LV0, SEED, 1080,
|
||||
deposit_eur=DEP_MAIN)
|
||||
d3 = float(np.abs(np.sort(brd["cash"]) - np.sort(mineb["rows"][0]["wealth"])).max())
|
||||
ok["R3"] = d3 < 1e-8
|
||||
print(f" R3 sim_split(phi=0) vs GC.book_road (stessi blocchi): max|diff| = ${d3:.3e}"
|
||||
f" {'IDENTICO' if ok['R3'] else 'DIVERGE'}")
|
||||
|
||||
# R4: gli estremi di §37, alla banda d'ancora (la cella mediana di §37 non e' pubblicata)
|
||||
print(f"\n R4 GLI ESTREMI DI §37 — le due strade intere, sulle {len(CELLS)} celle d'ancora")
|
||||
print(f" (§37 gira sulla SUA cella mediana, non pubblicata: qui si verifica che i suoi")
|
||||
print(f" numeri cadano DENTRO la banda, non che coincidano)")
|
||||
print(f"\n {'versamento':>11} {'strada':>10} {'mediana (banda celle)':>34} "
|
||||
f"{'media':>12} {'P(>=50/g)':>22}")
|
||||
r37, _r4 = {}, []
|
||||
for dep in (0.0, DEP_MAIN):
|
||||
for lab, phi in (("BIGLIETTO", 1.0), ("LIBRO", 0.0)):
|
||||
med, mea, p50 = [], [], []
|
||||
for c in CELLS:
|
||||
Rc, Gc, lvc, _ = RG[c]
|
||||
s = sim_split(Rc, Gc, rb, [(lab, "FIX", phi)], N_BASE, lvc, SEED, 1080,
|
||||
deposit_eur=dep)
|
||||
q = summ(s["rows"][0], perp)
|
||||
med.append(q["med_w"]); mea.append(q["mean_w"]); p50.append(q["p50_flow"])
|
||||
r37[(dep, lab)] = (np.median(med), np.median(mea), np.median(p50))
|
||||
pubm = PUB["med_tix_37"] if (dep and lab == "BIGLIETTO") else (
|
||||
PUB["med_book_37"] if dep else (PUB["med_tix_0"] if lab == "BIGLIETTO"
|
||||
else PUB["med_book_0"]))
|
||||
inside = min(med) <= pubm <= max(med)
|
||||
_r4.append(bool(inside))
|
||||
print(f" EUR{dep:>7,.0f}/m {lab:>10} ${np.median(med):>10,.0f} "
|
||||
f"[${min(med):>8,.0f},${max(med):>9,.0f}] ${np.median(mea):>11,.0f} "
|
||||
f"{np.median(p50):>9.1%} [{min(p50):>5.1%},{max(p50):>5.1%}] "
|
||||
f"{'PUB dentro' if inside else 'PUB fuori'}")
|
||||
ok["R4"] = all(_r4)
|
||||
print(f" §37 pubblica: BIGLIETTO EUR500 ${PUB['med_tix_37']:,.0f} / P {PUB['p50g_37']:.1%} · "
|
||||
f"LIBRO ${PUB['med_book_37']:,.0f} · BIGLIETTO EUR0 ${PUB['med_tix_0']:,.0f} · "
|
||||
f"LIBRO EUR0 ${PUB['med_book_0']:,.0f}")
|
||||
print(f"\n REPLICHE: {sum(ok.values())}/{len(ok)} "
|
||||
f"{'tutte OK' if all(ok.values()) else 'ATTENZIONE: ' + str([k for k,v in ok.items() if not v])}")
|
||||
if not (ok["R2"] and ok["R3"]):
|
||||
print(" Senza R2/R3 i numeri sotto sarebbero di un'altra macchina. STOP.")
|
||||
return
|
||||
|
||||
# ================================================================= §2 la curva
|
||||
hr(f"§2. LA CURVA DELLA FRAZIONE — 36 mesi, EUR {DEP_MAIN:.0f}/mese, {N_BASE} percorsi {clock()}")
|
||||
print(" Tutte le politiche girano nello STESSO Monte Carlo (blocchi impilati): stesso")
|
||||
print(" bootstrap, stessa morte-firm => ogni delta e' APPAIATO percorso per percorso.")
|
||||
POLS = make_policies(full=True)
|
||||
RES: dict = {}
|
||||
for c in CELLS:
|
||||
Rc, Gc, lvc, _ = RG[c]
|
||||
s = sim_split(Rc, Gc, rb, POLS, N_BASE, lvc, SEED, 1080, deposit_eur=DEP_MAIN)
|
||||
RES[c] = {r["lab"]: r for r in s["rows"]}
|
||||
print(f" cella {c} fatta {clock()}")
|
||||
CONTRIB = s["contributed"]
|
||||
|
||||
|
||||
fix_labs = [p[0] for p in POLS if p[1] == "FIX"]
|
||||
print(f"\n Versato in 36 mesi: ${CONTRIB:,.0f} (capitale iniziale ${START_EUR*EURUSD:,.0f} "
|
||||
f"+ 36 x EUR{DEP_MAIN:.0f})")
|
||||
print(f"\n {'phi':>6} {'P(>=50/g) FLUSSO':>26} {'P(>=50/g) RENDITA':>18} "
|
||||
f"{'ricch. MEDIANA':>26} {'media':>11} {'P(<versato)':>12} {'P(<$249)':>10} "
|
||||
f"{'EUR/g med':>10}")
|
||||
print(f" {'':>6} {'(la metrica di §37)':>26} {'(la metrica del PIANO)':>18}")
|
||||
curva = []
|
||||
for lab in fix_labs:
|
||||
q = {c: summ(RES[c][lab], perp) for c in CELLS}
|
||||
g = lambda k: float(np.median([q[c][k] for c in CELLS])) # noqa: E731
|
||||
lohi = lambda k: (min(q[c][k] for c in CELLS), max(q[c][k] for c in CELLS)) # noqa: E731
|
||||
p50, pl_, ph_ = g("p50_flow"), *lohi("p50_flow")
|
||||
mw, mlo, mhi = g("med_w"), *lohi("med_w")
|
||||
rendm = g("med_flow") + g("med_rend")
|
||||
curva.append(dict(lab=lab, phi=float(lab.split()[1]), p50=p50, med=mw,
|
||||
mean=g("mean_w"), ploss=g("p_loss"), pruin=g("p_ruin"),
|
||||
prend=g("p50_rend"), eurg=rendm))
|
||||
print(f" {lab.split()[1]:>6} {p50:>13.1%} [{pl_:>5.1%},{ph_:>5.1%}] "
|
||||
f"{g('p50_rend'):>17.1%} ${mw:>10,.0f} [${mlo:>7,.0f},${mhi:>8,.0f}] "
|
||||
f"${g('mean_w'):>10,.0f} {g('p_loss'):>12.1%} {g('p_ruin'):>10.1%} {rendm:>10.2f}")
|
||||
CV = pd.DataFrame(curva)
|
||||
a_p50 = CV.loc[CV["p50"].idxmax()]
|
||||
a_med = CV.loc[CV["med"].idxmax()]
|
||||
a_mean = CV.loc[CV["mean"].idxmax()]
|
||||
a_saf = CV.loc[CV["ploss"].idxmin()]
|
||||
print(f"\n ARGMAX PER COLONNA — la risposta al mandato punto 2:")
|
||||
print(f" P(>=50/g) flusso : phi = {a_p50['phi']:.2f} ({a_p50['p50']:.1%})")
|
||||
print(f" ricchezza MEDIANA: phi = {a_med['phi']:.2f} (${a_med['med']:,.0f})")
|
||||
print(f" ricchezza MEDIA : phi = {a_mean['phi']:.2f} (${a_mean['mean']:,.0f})")
|
||||
print(f" P(<versato) min : phi = {a_saf['phi']:.2f} ({a_saf['ploss']:.1%})")
|
||||
print(f" P(>=50/g) RENDITA: max {CV['prend'].max():.1%} su TUTTE le celle "
|
||||
f"-> {'nessuno arriva' if CV['prend'].max() < 0.005 else 'qualcuno arriva'}")
|
||||
print(f" >>> ATTESA A2 ('gli ottimi non coincidono'): "
|
||||
f"{'CONFERMATA' if len({round(a_p50['phi'],2), round(a_med['phi'],2)}) > 1 else 'SMENTITA'}")
|
||||
|
||||
# ---- risoluzione MC, misurata (mandato: riportarla accanto a ogni delta) --------------
|
||||
print(f"\n §2.1 RISOLUZIONE MONTE CARLO — misurata su 3 semi (non assunta) {clock()}")
|
||||
probe = [("F 0.00", "FIX", 0.0), ("F 0.50", "FIX", 0.5), ("F 1.00", "FIX", 1.0)]
|
||||
Rc, Gc, lvc, _ = RG[CELLS[0]]
|
||||
seeds = (SEED, SEED + 101, SEED + 202)
|
||||
tabS = {}
|
||||
for sd in seeds:
|
||||
s = sim_split(Rc, Gc, rb, probe, N_BASE, lvc, sd, 1080, deposit_eur=DEP_MAIN)
|
||||
tabS[sd] = {r["lab"]: summ(r, perp) for r in s["rows"]}
|
||||
sp_lvl = max(max(tabS[sd][l]["p50_flow"] for sd in seeds)
|
||||
- min(tabS[sd][l]["p50_flow"] for sd in seeds) for l in ("F 0.50", "F 1.00"))
|
||||
d_pair = [tabS[sd]["F 1.00"]["p50_flow"] - tabS[sd]["F 0.50"]["p50_flow"] for sd in seeds]
|
||||
sp_pair = max(d_pair) - min(d_pair)
|
||||
print(f" {'seme':>10} {'P50 phi=0.5':>13} {'P50 phi=1.0':>13} {'delta appaiato':>16} "
|
||||
f"{'med. ricch. phi=0':>18}")
|
||||
for sd in seeds:
|
||||
print(f" {sd:>10} {tabS[sd]['F 0.50']['p50_flow']:>13.2%} "
|
||||
f"{tabS[sd]['F 1.00']['p50_flow']:>13.2%} "
|
||||
f"{tabS[sd]['F 1.00']['p50_flow']-tabS[sd]['F 0.50']['p50_flow']:>+16.2%} "
|
||||
f"${tabS[sd]['F 0.00']['med_w']:>17,.0f}")
|
||||
print(f" ampiezza fra semi: LIVELLI {sp_lvl*100:.2f} pp · DIFFERENZE APPAIATE "
|
||||
f"{sp_pair*100:.2f} pp -> ogni delta sotto ~{max(sp_pair,0.0)*100:.1f} pp e' RUMORE")
|
||||
|
||||
# ================================================================= §3 politiche di stato
|
||||
hr(f"§3. LE POLITICHE DIPENDENTI DALLO STATO — famiglia dichiarata prima {clock()}")
|
||||
print(f" {'politica':>16} {'P(>=50/g)':>22} {'ricch. mediana':>15} {'media':>11} "
|
||||
f"{'P(<versato)':>12} {'P(<$249)':>10} {'$ ai biglietti':>15} {'biglietti':>10}")
|
||||
fam = [p[0] for p in POLS if p[1] in ("TIX", "BOOK", "PHI_UP", "PHI_DN", "CASH")]
|
||||
ref_lab = "F 1.00"
|
||||
qref = {c: summ(RES[c][ref_lab], perp) for c in CELLS}
|
||||
for lab in [ref_lab, "F 0.00"] + fam:
|
||||
q = {c: summ(RES[c][lab], perp) for c in CELLS}
|
||||
g = lambda k: float(np.median([q[c][k] for c in CELLS])) # noqa: E731
|
||||
dp = float(np.median([q[c]["p50_flow"] - qref[c]["p50_flow"] for c in CELLS]))
|
||||
npos = sum(1 for c in CELLS if q[c]["p50_flow"] - qref[c]["p50_flow"] > 0)
|
||||
mark = "" if lab == ref_lab else f" d {dp*100:+5.2f}pp ({npos}/{len(CELLS)})"
|
||||
print(f" {lab:>16} {g('p50_flow'):>9.1%}{mark:>13} ${g('med_w'):>14,.0f} "
|
||||
f"${g('mean_w'):>10,.0f} {g('p_loss'):>12.1%} {g('p_ruin'):>10.1%} "
|
||||
f"${g('med_tix'):>14,.0f} {g('nbuy'):>10.1f}")
|
||||
tixb = float(np.median([summ(RES[c]["TIX $5,000"], perp)["p50_flow"] for c in CELLS]))
|
||||
bookb = float(np.median([summ(RES[c]["BOOK $5,000"], perp)["p50_flow"] for c in CELLS]))
|
||||
up = float(np.median([summ(RES[c]["PHI_UP $10k"], perp)["p50_flow"] for c in CELLS]))
|
||||
dn = float(np.median([summ(RES[c]["PHI_DN $10k"], perp)["p50_flow"] for c in CELLS]))
|
||||
print(f"\n >>> ATTESA A1 (front-loaded): TIX $5k {tixb:.1%} contro BOOK $5k {bookb:.1%} "
|
||||
f"-> {'CONFERMATA' if tixb > bookb else 'SMENTITA'}; "
|
||||
f"phi DECRESCENTE {dn:.1%} contro CRESCENTE {up:.1%} "
|
||||
f"-> {'CONFERMATA' if dn > up else 'SMENTITA'}")
|
||||
cashp = {c: summ(RES[c]["CASH-ATT $1.2k"], perp) for c in CELLS}
|
||||
d_cash = float(np.median([cashp[c]["med_w"] - qref[c]["med_w"] for c in CELLS]))
|
||||
d_cash50 = float(np.median([cashp[c]["p50_flow"] - qref[c]["p50_flow"] for c in CELLS]))
|
||||
print(f" CASH-ATT (l'unica che puo' dominare phi=1): ricchezza mediana "
|
||||
f"${d_cash:+,.0f}, P(>=50/g) {d_cash50*100:+.2f}pp "
|
||||
f"({sum(1 for c in CELLS if cashp[c]['med_w'] > qref[c]['med_w'])}/{len(CELLS)} celle)")
|
||||
|
||||
# ================================================================= §4 il trabocchetto §44
|
||||
hr(f"§4. IL TRABOCCHETTO DI §44 — la CONDIZIONE davanti al bonifico {clock()}")
|
||||
print(" §44: «comprare meglio e comprare tardi sono la stessa mossa». Qui la condizione non")
|
||||
print(" ritarda un BONIFICO ma un ACQUISTO di biglietto. Si separa il costo della CONDIZIONE")
|
||||
print(" da quello del RITARDO con un GEMELLO DETERMINISTICO di pari attesa media.")
|
||||
print(f"\n {'politica':>14} {'attesa media (g)':>18} {'P(>=50/g)':>11} {'d appaiato':>12} "
|
||||
f"{'ricch. mediana':>15} {'d':>11}")
|
||||
# attesa media della condizione, misurata sulla stessa serie
|
||||
for lab in ("F 1.00", "RARE dd 10%", "RARE dd 20%", "DELAY 95g", "DELAY 713g"):
|
||||
q = {c: summ(RES[c][lab], perp) for c in CELLS}
|
||||
g = lambda k: float(np.median([q[c][k] for c in CELLS])) # noqa: E731
|
||||
dp = float(np.median([q[c]["p50_flow"] - qref[c]["p50_flow"] for c in CELLS]))
|
||||
dm = float(np.median([q[c]["med_w"] - qref[c]["med_w"] for c in CELLS]))
|
||||
wait = {"F 1.00": 0.0, "DELAY 95g": 95.0, "DELAY 713g": 713.0}.get(lab, float("nan"))
|
||||
if np.isnan(wait):
|
||||
d_ = float(lab.split()[-1].rstrip("%")) / 100.0
|
||||
eqp = np.cumprod(1.0 + PV.deluck(rb))
|
||||
dd = eqp / np.maximum.accumulate(eqp) - 1.0
|
||||
hit = np.flatnonzero(dd <= -d_)
|
||||
wait = float(hit[0]) if len(hit) else float("inf")
|
||||
print(f" {lab:>14} {wait:>18.0f} {g('p50_flow'):>11.1%} {dp*100:>+11.2f}pp "
|
||||
f"${g('med_w'):>14,.0f} ${dm:>+10,.0f}")
|
||||
print(" (l'attesa di RARE e' il primo giorno in cui la condizione si verifica sulla serie")
|
||||
print(" storica de-luckata: nel bootstrap e' una variabile aleatoria, qui e' un'ancora)")
|
||||
|
||||
# ================================================================= §5 la scala
|
||||
hr(f"§5. I RENDIMENTI DI SCALA — la previsione A1, misurata direttamente {clock()}")
|
||||
print(" Il canale BIGLIETTO assorbe soldi solo a gradini (prezzo fisso, 6 slot, cap firm).")
|
||||
print(" Quanto ne assorbe davvero, e quando satura?")
|
||||
Rc, Gc, lvc, _ = RG[CELLS[0]]
|
||||
print(f"\n {'versamento':>12} {'$ versati ai bigl.':>19} {'$ SPESI in biglietti':>21} "
|
||||
f"{'assorbimento':>13} {'cassa finale med':>17} {'biglietti comprati':>19}")
|
||||
for dep in (0.0, 250.0, 500.0, 1_000.0, 2_000.0):
|
||||
s = sim_split(Rc, Gc, rb, [("F 1.00", "FIX", 1.0)], N_BASE, lvc, SEED, 1080,
|
||||
deposit_eur=dep)
|
||||
r = s["rows"][0]
|
||||
got = float(np.mean(r["to_tix"]))
|
||||
sp = float(np.mean(r["spent"]))
|
||||
print(f" EUR{dep:>8,.0f}/m ${got:>18,.0f} ${sp:>20,.0f} {sp/max(got,1e-9):>12.1%} "
|
||||
f"${np.median(r['cash']):>16,.0f} {np.mean(r['nbuy']):>19.1f}")
|
||||
print(" ('assorbimento' = quanta parte dei soldi mandati al pot biglietti finisce davvero")
|
||||
print(" in un biglietto; il resto resta CASSA FERMA — e' il costo dell'indivisibilita'.)")
|
||||
|
||||
print(f"\n §5.1 LA FRAZIONE CONTRO L'IMPORTO — la domanda che decide {clock()}")
|
||||
print(f" {'versamento':>12} {'phi=0 P(>=50/g)':>16} {'phi=1 P(>=50/g)':>16} "
|
||||
f"{'ampiezza phi':>13} {'phi=0 ricch.med':>16} {'phi=1 ricch.med':>16}")
|
||||
prev = None
|
||||
imp_rows = []
|
||||
for dep in (0.0, 250.0, 500.0, 1_000.0):
|
||||
s = sim_split(Rc, Gc, rb, [("F 0.00", "FIX", 0.0), ("F 1.00", "FIX", 1.0)],
|
||||
N_BASE, lvc, SEED, 1080, deposit_eur=dep)
|
||||
q0, q1 = summ(s["rows"][0], perp), summ(s["rows"][1], perp)
|
||||
imp_rows.append((dep, q0, q1))
|
||||
print(f" EUR{dep:>8,.0f}/m {q0['p50_flow']:>16.1%} {q1['p50_flow']:>16.1%} "
|
||||
f"{(q1['p50_flow']-q0['p50_flow'])*100:>+12.1f}pp ${q0['med_w']:>15,.0f} "
|
||||
f"${q1['med_w']:>15,.0f}")
|
||||
prev = (q0, q1)
|
||||
d_phi = imp_rows[2][2]["p50_flow"] - imp_rows[2][1]["p50_flow"]
|
||||
d_dep_tix = imp_rows[2][2]["p50_flow"] - imp_rows[1][2]["p50_flow"]
|
||||
d_dep_book = imp_rows[2][1]["med_w"] - imp_rows[1][1]["med_w"]
|
||||
print(f"\n A EUR500/m: passare phi 0->1 vale {d_phi*100:+.1f}pp di P(>=50/g); passare il")
|
||||
print(f" VERSAMENTO da EUR250 a EUR500 (a phi=1) vale {d_dep_tix*100:+.1f}pp.")
|
||||
print(f" Sulla RICCHEZZA (phi=0): EUR250 -> EUR500 vale ${d_dep_book:+,.0f} di mediana.")
|
||||
|
||||
# ================================================================= §6 60 mesi
|
||||
hr(f"§6. ORIZZONTE 60 MESI — l'unica ragione strutturale per cui l'ottimo dovrebbe muoversi {clock()}")
|
||||
p5 = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** 5
|
||||
print(f" A 5 anni ogni firm muore con p = {p5:.0%}; entrambe con p = {p5**2:.0%}. Il canale")
|
||||
print(f" biglietto ha VITA FINITA, il libro no. Attesa A3: l'ottimo phi SCENDE.")
|
||||
POLS60 = ([("F 0.00", "FIX", 0.0), ("F 0.20", "FIX", 0.20), ("F 0.50", "FIX", 0.50),
|
||||
("F 0.80", "FIX", 0.80), ("F 1.00", "FIX", 1.0),
|
||||
("TIX $5,000", "TIX", 5_000.0), ("BOOK $5,000", "BOOK", 5_000.0),
|
||||
("PHI_DN $10k", "PHI_DN", 10_000.0), ("CASH-ATT $1.2k", "CASH", 1_200.0)])
|
||||
R60: dict = {}
|
||||
for c in CELLS[:3]:
|
||||
Rc2, Gc2, lvc2, _ = RG[c]
|
||||
s = sim_split(Rc2, Gc2, rb, POLS60, N_BASE, lvc2, SEED, 1800, deposit_eur=DEP_MAIN)
|
||||
R60[c] = {r["lab"]: r for r in s["rows"]}
|
||||
print(f"\n {'politica':>16} {'P(>=50/g) 36m':>14} {'P(>=50/g) 60m':>14} {'ricch.med 60m':>15} "
|
||||
f"{'media 60m':>12} {'P(<versato)':>12} {'P(>=50/g) RENDITA 60m':>22}")
|
||||
for lab, _, _ in POLS60:
|
||||
q36 = float(np.median([summ(RES[c][lab], perp)["p50_flow"] for c in CELLS[:3]]))
|
||||
q = {c: summ(R60[c][lab], perp) for c in CELLS[:3]}
|
||||
g = lambda k: float(np.median([q[c][k] for c in CELLS[:3]])) # noqa: E731
|
||||
print(f" {lab:>16} {q36:>14.1%} {g('p50_flow'):>14.1%} ${g('med_w'):>14,.0f} "
|
||||
f"${g('mean_w'):>11,.0f} {g('p_loss'):>12.1%} {g('p50_rend'):>22.1%}")
|
||||
c60 = pd.DataFrame([dict(phi=float(l.split()[1]),
|
||||
p50=float(np.median([summ(R60[c][l], perp)["p50_flow"]
|
||||
for c in CELLS[:3]])),
|
||||
med=float(np.median([summ(R60[c][l], perp)["med_w"]
|
||||
for c in CELLS[:3]])))
|
||||
for l, k, _ in POLS60 if k == "FIX"])
|
||||
print(f"\n argmax P(>=50/g): 36 mesi phi={a_p50['phi']:.2f} · 60 mesi "
|
||||
f"phi={c60.loc[c60['p50'].idxmax(),'phi']:.2f}")
|
||||
print(f" argmax ricchezza mediana: 36 mesi phi={a_med['phi']:.2f} · 60 mesi "
|
||||
f"phi={c60.loc[c60['med'].idxmax(),'phi']:.2f}")
|
||||
print(f" >>> ATTESA A3 ('a 60 mesi l'ottimo phi scende'): "
|
||||
f"{'CONFERMATA' if c60.loc[c60['p50'].idxmax(),'phi'] < a_p50['phi'] else 'SMENTITA'}")
|
||||
|
||||
# ================================================================= §7 verdetto
|
||||
hr(f"§7. VERDETTO {clock()}")
|
||||
sp = max(sp_pair, 0.0) * 100
|
||||
rng_p50 = (CV["p50"].max() - CV["p50"].min()) * 100
|
||||
rng_med = CV["med"].max() - CV["med"].min()
|
||||
print(f" Ampiezza della CURVA fra phi=0 e phi=1 (36 mesi, EUR{DEP_MAIN:.0f}/m):")
|
||||
print(f" P(>=50/g) flusso : {rng_p50:.1f} pp (risoluzione MC {sp:.1f} pp) -> "
|
||||
f"{'SEGNALE' if rng_p50 > 3*sp else 'DENTRO IL RUMORE'}")
|
||||
print(f" ricchezza mediana: ${rng_med:,.0f}")
|
||||
print(f" P(>=50/g) rendita: {(CV['prend'].max()-CV['prend'].min())*100:.1f} pp")
|
||||
print(f" P(<versato) : {(CV['ploss'].max()-CV['ploss'].min())*100:.1f} pp")
|
||||
print(f"\n In EUR/giorno (mediana, flusso + rendita terminale — le due NON si sommano")
|
||||
print(f" senza doppio conteggio, si leggono separate):")
|
||||
for lab in ("F 0.00", "F 0.50", "F 1.00"):
|
||||
row = CV[CV["lab"] == lab].iloc[0]
|
||||
print(f" {lab}: EUR {row['eurg']:.2f}/giorno mediani a 36 mesi")
|
||||
print(f"\n Il target e' EUR {TARGET:.0f}/giorno.")
|
||||
print(f" TRIALS: nessuna cella SELEZIONATA (la famiglia e' dichiarata nel docstring e tutte")
|
||||
print(f" le celle sono riportate) -> nessun deflated-Sharpe da calcolare; e la grandezza")
|
||||
print(f" misurata e' una P, non uno Sharpe.")
|
||||
print(f"\n {clock()} fine.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user