Adriano Dal Pastro
812 lines
47 KiB
Python
812 lines
47 KiB
Python
"""r0822b_depeg.py — IL FALSIFICATORE DI VENUE PER XS01-OOS (2026-08-22, ondata wave-0822).
|
|
|
|
IL PUNTO FRAGILE, DICHIARATO DALL'AUTORE DEL RISULTATO
|
|
-----------------------------------------------------
|
|
`r0822b_xs01_oos.py` (RESULTS-0822 §21) ha misurato che il meccanismo congelato di XS01 ha un edge
|
|
FUORI dalla sua finestra di scoperta — 2021-2023 su **Binance spot USDT** — e che li' e' PIU' GRANDE
|
|
(mediana di fase +1,12 contro +0,37, differenza appaiata +0,668 in 10/10 fasi). Quel risultato
|
|
riscrive il gate del canale funded, quindi merita il suo falsificatore.
|
|
|
|
Lo stesso autore lo ha nominato:
|
|
> "La validazione di venue Binance-vs-Hyperliquid gira SOLO sulla finestra comune 2024+, cioe'
|
|
> proprio il periodo SENZA depeg USDT. Il fuori campione contiene il depeg di maggio 2022. Se i
|
|
> close Binance/USDT 2021-2023 divergessero da un venue USD in modo NON COMUNE fra gli asset, il
|
|
> ranking cambierebbe e il risultato con esso. Test che lo deciderebbe: rifare il meccanismo sui
|
|
> close Coinbase USD per il sottoinsieme quotato li', 2021-2023, e chiedere corr fra i due sleeve
|
|
> >= 0.99 come sul 2024+."
|
|
|
|
Questo script esegue esattamente quel test.
|
|
|
|
PERCHE' LA DOMANDA NON E' OZIOSA (il meccanismo del danno, prima dei numeri)
|
|
---------------------------------------------------------------------------
|
|
La regola del progetto — "Binance non e' la verita', e' USDT, ~10 bps fuori, e sotto depeg fino al
|
|
3% off" — e' stata **correttamente** giudicata non-binding da §21: uno z-score cross-sezionale
|
|
sottrae la media di sezione, quindi e' invariante a un fattore **COMUNE**. Ma un depeg non e'
|
|
garantito comune: nei giorni di stress la liquidita' si sposta in modo diverso per asset (i major
|
|
restano scambiati contro USDT, i minori no; i flussi di fuga passano per coppie diverse), e una
|
|
divergenza **IDIOSINCRATICA** cambia il RANKING — che e' esattamente cio' che la strategia legge.
|
|
Maggio 2022 (UST/LUNA, con USDT sceso a ~0,95) e' il caso peggiore possibile.
|
|
Percio' la divergenza va misurata in DUE pezzi, e sono due domande diverse:
|
|
(a) COMUNE = mediana per giorno dello scarto fra i venue -> quella che lo z-score annulla;
|
|
(b) IDIOSINCRATICA = scarto per asset DOPO aver tolto la mediana del giorno -> quella che uccide.
|
|
Riportare solo (a) darebbe la risposta rassicurante e sbagliata.
|
|
|
|
IL VINCOLO DEL DATO, E COME E' STATO RISOLTO (dichiarato PRIMA di misurare)
|
|
--------------------------------------------------------------------------
|
|
Su Coinbase USD, dei 13 asset di U13:
|
|
BNB -> quotato solo dal 2025-10 = FUORI (nessun venue USD ce l'ha nel 2021-23: e' l'asset
|
|
nativo del venue che stiamo mettendo in discussione)
|
|
XRP -> SOSPESO su Coinbase dal 2021-01-19 al 2023-07 (causa SEC) = buco proprio sulla finestra
|
|
NEAR/INJ -> quotati su Coinbase solo dal 2022-09
|
|
AVAX -> dal 2021-09-30 (il vincolo che decide l'inizio della finestra)
|
|
XRP e' recuperato da **Bitstamp USD** (l'altra referenza USD del `venue_watch` del progetto, che
|
|
non ha mai sospeso la coppia). Restano fuori BNB, NEAR, INJ.
|
|
Ne escono DUE test, e il secondo copre cio' che il primo non copre:
|
|
|
|
TEST 1 "U10-USD" = universo FISSO di 10 gambe (BTC ETH LTC LINK AAVE ADA DOGE SOL AVAX + XRP),
|
|
2021-09-30 -> 2023-12-31, meccanismo **CONGELATO** (k=5, min_assets=10:
|
|
dieci gambe sono ESATTAMENTE il minimo, nessun parametro toccato).
|
|
Contiene il depeg di maggio 2022 e FTX. NON contiene il 2021.
|
|
TEST 2 "U13-IBRIDO" = i 13 asset e la finestra INTERA 2021-01 -> 2023-12, con il close USD
|
|
sostituito a quello USDT **dove esiste** (9-12 gambe su 13 a seconda della
|
|
data) e Binance dove non esiste. Non e' un confronto puro di venue, e'
|
|
la domanda operativa: *se sostituisco tutto il prezzo USD che esiste, il
|
|
risultato di §21 si muove?*
|
|
In entrambi i test il confronto e' **APPAIATO**: stesso sottoinsieme, stessa finestra, stesse 10
|
|
fasi, stesso codice del motore. Confrontare "19 gambe su Binance" con "10 su Coinbase" misurerebbe
|
|
l'UNIVERSO, non il venue (regola del progetto: un confronto appaiato eredita TUTTI i parametri
|
|
della riga in cui compare) — e per questo il TEST 1 riporta anche cosa fa U10 **su Binance**
|
|
rispetto a U13 su Binance, cioe' quanto del titolo di §21 questo sottoinsieme riproduce.
|
|
|
|
MECCANISMO: CONGELATO. Il motore e' importato da `r0822b_xs01_oos.py` (che a sua volta replica
|
|
`sleeves._xsec_returns` a max|diff| = 0.0). Nessuna riga di strategia riscritta qui: se il motore
|
|
fosse riscritto, una differenza di venue e una differenza di implementazione sarebbero
|
|
indistinguibili.
|
|
|
|
Uso: nice -n 19 timeout 900 uv run python scripts/research/r0822b_depeg.py
|
|
Rete: sola lettura, <= 2 req/s, MAI nella finestra :25-:29 (rate limit per-IP condiviso col
|
|
collettore della catena opzioni; guasto del 29/07). Download in cache nello scratchpad: la
|
|
seconda corsa e' offline.
|
|
"""
|
|
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]
|
|
sys.path.insert(0, str(ROOT))
|
|
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
|
sys.path.insert(0, str(ROOT / "scripts" / "research" / "alt"))
|
|
|
|
import altlib as A # noqa: E402
|
|
import r0822b_xs01_oos as X # noqa: E402 (motore CONGELATO + cache Binance)
|
|
from src.portfolio.sleeves import XS_CFG # noqa: E402
|
|
|
|
CACHE = X.CACHE.parent / "r0822b_depeg"
|
|
CACHE.mkdir(parents=True, exist_ok=True)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# UNIVERSI E FINESTRE — dichiarati PRIMA di guardare i numeri
|
|
# ---------------------------------------------------------------------------
|
|
U13 = X.U13 # l'universo di §21
|
|
# venue USD per asset. `None` = nessun venue USD con storia sulla finestra.
|
|
USD_SRC: dict[str, tuple[str, str] | None] = {
|
|
"BTC": ("coinbase", "BTC/USD"), "ETH": ("coinbase", "ETH/USD"),
|
|
"LTC": ("coinbase", "LTC/USD"), "LINK": ("coinbase", "LINK/USD"),
|
|
"AAVE": ("coinbase", "AAVE/USD"), "ADA": ("coinbase", "ADA/USD"),
|
|
"DOGE": ("coinbase", "DOGE/USD"), "SOL": ("coinbase", "SOL/USD"),
|
|
"AVAX": ("coinbase", "AVAX/USD"), "NEAR": ("coinbase", "NEAR/USD"),
|
|
"INJ": ("coinbase", "INJ/USD"),
|
|
"XRP": ("bitstamp", "XRP/USD"), # Coinbase l'ha sospeso 2021-01 -> 2023-07
|
|
"BNB": None, # nessun venue USD prima del 2025-10
|
|
}
|
|
U10 = ["BTC", "ETH", "LTC", "LINK", "AAVE", "ADA", "DOGE", "SOL", "AVAX", "XRP"]
|
|
T1_START, T1_END = "2021-09-30", "2024-01-01" # AVAX su Coinbase e' il vincolo
|
|
T2_START, T2_END = "2021-01-01", "2024-01-01" # la finestra fuori campione di §21
|
|
DEPEG = ("2022-05-07", "2022-05-21") # UST/LUNA + USDT a ~0.95 (estremo incluso)
|
|
PHASES = list(range(XS_CFG["H"])) # 10 fasi: la stima onesta e' la MEDIANA
|
|
CORR_SOGLIA = 0.99 # soglia DICHIARATA DALL'AUTORE, non da me
|
|
|
|
|
|
# ===========================================================================
|
|
# 1. FETCH USD (Coinbase / Bitstamp) + certificazione locale
|
|
# ===========================================================================
|
|
def _fetch_paged(ex, market: str, tf: str, start_ms: int, end_ms: int,
|
|
step_bars: int, bar_ms: int) -> list:
|
|
"""Paginazione DETERMINISTICA sulla finestra: avanza anche quando una pagina torna vuota.
|
|
|
|
⚠️ Non e' un dettaglio: XRP su Coinbase ha un buco di 2,5 anni (sospensione SEC) e un loop che
|
|
si ferma alla prima pagina vuota — il modo ovvio di scrivere questo ciclo — troncherebbe la
|
|
serie li', producendo un 'asset che non esiste' invece di un 'asset con un buco'. Sono due
|
|
fatti diversi e portano a due decisioni diverse.
|
|
"""
|
|
rows, cur, span = [], start_ms, step_bars * bar_ms
|
|
while cur < end_ms:
|
|
X._outside_forbidden_window()
|
|
batch = []
|
|
for attempt in range(3):
|
|
try:
|
|
batch = ex.fetch_ohlcv(market, tf, since=cur, limit=step_bars)
|
|
break
|
|
except Exception as e: # noqa: BLE001
|
|
if attempt == 2:
|
|
print(f" [rete] {market} @ {cur}: {type(e).__name__} {str(e)[:70]}")
|
|
time.sleep(2 ** attempt)
|
|
time.sleep(0.55) # <= 2 req/s
|
|
rows += [b for b in (batch or []) if cur <= b[0] < cur + span]
|
|
cur += span
|
|
return rows
|
|
|
|
|
|
def fetch_usd_daily(asset: str) -> pd.DataFrame:
|
|
"""Close giornalieri USD dal venue dichiarato in USD_SRC. Cache su disco."""
|
|
src = USD_SRC.get(asset)
|
|
if src is None:
|
|
return pd.DataFrame(columns=["timestamp", "close", "volume"])
|
|
venue, market = src
|
|
f = CACHE / f"{venue[:2]}_{asset.lower()}_1d.parquet"
|
|
if f.exists():
|
|
return pd.read_parquet(f)
|
|
import ccxt
|
|
ex = getattr(ccxt, venue)({"enableRateLimit": True})
|
|
ex.load_markets()
|
|
if market not in ex.markets:
|
|
d = pd.DataFrame(columns=["timestamp", "open", "high", "low", "close", "volume"])
|
|
d.to_parquet(f)
|
|
return d
|
|
start = ex.parse8601("2019-01-01T00:00:00Z")
|
|
end = int(time.time() * 1000)
|
|
step = 300 if venue == "coinbase" else 1000
|
|
rows = _fetch_paged(ex, market, "1d", start, end, step, 86_400_000)
|
|
d = (pd.DataFrame(rows, columns=["timestamp", "open", "high", "low", "close", "volume"])
|
|
.drop_duplicates("timestamp").sort_values("timestamp").reset_index(drop=True))
|
|
d.to_parquet(f)
|
|
return d
|
|
|
|
|
|
def series_of(d: pd.DataFrame) -> pd.Series:
|
|
if not len(d):
|
|
# indice tz-aware anche da vuoto: un asset senza venue USD (BNB) deve poter essere
|
|
# confrontato/reindicizzato come gli altri, non far cadere lo script
|
|
return pd.Series(dtype=float, index=pd.DatetimeIndex([], tz="UTC"))
|
|
return pd.Series(d["close"].values.astype(float),
|
|
index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
|
|
|
|
|
|
def certify_usd(asset: str, d: pd.DataFrame, a: str, b: str) -> dict:
|
|
"""Stessa forma della certificazione di §21, ma valutata SULLA FINESTRA DEL TEST.
|
|
|
|
Certificare "tutta la serie" direbbe la cosa sbagliata: XRP su Coinbase ha 900 giorni di buco
|
|
che sulla finestra 2021-09/2023-12 sono TUTTI dentro. Il numero utile e' la copertura della
|
|
finestra in cui il meccanismo gira, non della serie.
|
|
"""
|
|
s = series_of(d)
|
|
s = s[(s.index >= pd.Timestamp(a, tz="UTC")) & (s.index < pd.Timestamp(b, tz="UTC"))]
|
|
if not len(s):
|
|
return dict(sym=asset, n=0, ok=False, start="-", end="-", gap=-1,
|
|
flat=float("nan"), zero_vol=float("nan"))
|
|
v = series_of(d.assign(close=d["volume"]))
|
|
v = v[(v.index >= pd.Timestamp(a, tz="UTC")) & (v.index < pd.Timestamp(b, tz="UTC"))]
|
|
# ⚠️ la copertura si misura sulla finestra RICHIESTA, non sulla prima barra disponibile:
|
|
# contando dal proprio inizio, un asset quotato a meta' finestra esce con gap=0 e "OK", e il
|
|
# conteggio degli usabili contraddirebbe la riga sotto che lo esclude. E' lo stesso difetto
|
|
# che il progetto ha gia' incontrato due volte (serie TRONCATA che passa ogni controllo
|
|
# interno): un controllo che guarda solo DENTRO la serie non vede cio' che la serie non copre.
|
|
attesi = (pd.Timestamp(b, tz="UTC") - pd.Timestamp(a, tz="UTC")).days
|
|
c = s.values
|
|
flat = float(np.mean(c[1:] == c[:-1])) if len(c) > 1 else float("nan")
|
|
zv = float(np.mean(v.values == 0.0)) if len(v) else float("nan")
|
|
gap = int(attesi - len(s))
|
|
return dict(sym=asset, n=len(s), start=str(s.index.min().date()),
|
|
end=str(s.index.max().date()), gap=gap, flat=flat, zero_vol=zv,
|
|
ok=bool(gap == 0 and flat < 0.02 and (not np.isfinite(zv) or zv < 0.01)))
|
|
|
|
|
|
# ===========================================================================
|
|
# 2. pannelli
|
|
# ===========================================================================
|
|
def bin_panel(syms: list[str]) -> pd.DataFrame:
|
|
"""Pannello Binance USDT — dalla cache di §21, cosi' il lato USDT del confronto e' BIT-IDENTICO
|
|
a quello che ha prodotto il risultato che sto falsificando."""
|
|
return pd.concat({s: series_of(X.fetch_binance_daily(s)) for s in syms}, axis=1).sort_index()
|
|
|
|
|
|
def usd_panel(syms: list[str]) -> pd.DataFrame:
|
|
return pd.concat({s: series_of(fetch_usd_daily(s)) for s in syms}, axis=1).sort_index()
|
|
|
|
|
|
def splice(usd: pd.Series, usdt: pd.Series) -> pd.Series:
|
|
"""Serie IBRIDA: USD dove esiste, USDT prima — RI-SCALANDO il tratto USDT al livello USD nel
|
|
giorno del giunto.
|
|
|
|
⚠️ Senza la ri-scalatura il giunto crea un rendimento fantasma pari allo scarto fra i venue
|
|
(pochi bps, ma esattamente il tipo di artefatto che questo script deve misurare, non fabbricare).
|
|
Il meccanismo legge RAPPORTI di prezzo a 30 e 90 giorni: dopo la ri-scalatura la serie e'
|
|
continua e i rapporti che attraversano il giunto sono ben definiti.
|
|
"""
|
|
u = usd.dropna()
|
|
if not len(u):
|
|
return usdt
|
|
t0 = u.index[0]
|
|
if t0 not in usdt.index or not np.isfinite(usdt.get(t0, np.nan)):
|
|
return usd.reindex(usdt.index)
|
|
k = float(u.iloc[0]) / float(usdt.loc[t0])
|
|
pre = usdt[usdt.index < t0] * k
|
|
return pd.concat([pre, u]).sort_index().reindex(usdt.index)
|
|
|
|
|
|
def hybrid_panel(syms: list[str]) -> tuple[pd.DataFrame, dict]:
|
|
B, U = bin_panel(syms), usd_panel(syms)
|
|
cols, meta = {}, {}
|
|
for s in syms:
|
|
u = U[s] if s in U.columns else pd.Series(dtype=float)
|
|
u = u.reindex(B.index)
|
|
cols[s] = splice(u, B[s])
|
|
cov = u.dropna()
|
|
meta[s] = (str(cov.index[0].date()) if len(cov) else "mai")
|
|
return pd.concat(cols, axis=1).sort_index(), meta
|
|
|
|
|
|
# ===========================================================================
|
|
# 3. metriche e allineamento appaiato
|
|
# ===========================================================================
|
|
sh, dd, cagr, win, alive, line = X.sh, X.dd, X.cagr, X.win, X.alive, X.line
|
|
|
|
|
|
def pair(a: pd.Series, b: pd.Series) -> tuple[pd.Series, pd.Series]:
|
|
"""Allinea due sleeve sullo stesso indice: un confronto di venue non puo' confrontare finestre."""
|
|
j = pd.concat({"a": a, "b": b}, axis=1, join="inner").dropna()
|
|
return j["a"], j["b"]
|
|
|
|
|
|
def ranking_scan(PB: pd.DataFrame, PU: pd.DataFrame, phases: list[int],
|
|
label: str) -> pd.DataFrame:
|
|
"""IL CANALE DEL DANNO, misurato dove passa: il venue puo' far male SOLO cambiando le gambe
|
|
scelte. Scansione di TUTTE le fasi (non solo la canonica: un ribaltamento su una fase sola
|
|
sarebbe invisibile all'ancora 0) con self-check dello specchio contro il motore."""
|
|
from scipy.stats import spearmanr
|
|
lb = XS_CFG["lookbacks"]
|
|
mlb, H, k = max(lb), XS_CFG["H"], XS_CFG["k"]
|
|
rows, sp, checked, tot = [], [], 0, 0
|
|
for ph in phases:
|
|
det: dict = {}
|
|
X.xsec_engine(PB, phase=ph, detail=det)
|
|
WB = det["W"]
|
|
for i in range(mlb, len(PB)):
|
|
if i % H != ph:
|
|
continue
|
|
iB, sB = score_at(PB, i, lb)
|
|
iU, sU = score_at(PU, i, lb)
|
|
if len(iB) < 10 or len(iU) < 10:
|
|
continue
|
|
tot += 1
|
|
oB = np.argsort(sB)
|
|
loB, hiB = set(iB[oB[:k]]), set(iB[oB[-k:]])
|
|
mh, ml = set(np.flatnonzero(WB[i] > 0)), set(np.flatnonzero(WB[i] < 0))
|
|
if mh or ml: # self-check solo dove il motore ha una posizione
|
|
checked += 1
|
|
if (mh, ml) != (hiB, loB):
|
|
raise AssertionError(f"specchio != motore ({label}, fase {ph}, i={i}): "
|
|
"misurerei la mia riscrittura invece del venue")
|
|
oU = np.argsort(sU)
|
|
loU, hiU = set(iU[oU[:k]]), set(iU[oU[-k:]])
|
|
ov = (len(hiB & hiU) + len(loB & loU)) / (2 * k)
|
|
sp.append(float(spearmanr(sB, sU).statistic))
|
|
if ov < 1.0:
|
|
diff = sorted(set(PB.columns[list(hiB ^ hiU)]) | set(PB.columns[list(loB ^ loU)]))
|
|
rows.append(dict(fase=ph, data=PB.index[i], overlap=ov, gambe=",".join(diff)))
|
|
D = pd.DataFrame(rows, columns=["fase", "data", "overlap", "gambe"])
|
|
print(f" [{label}] {tot} ribilanciamenti su {len(phases)} fasi; specchio verificato "
|
|
f"contro il motore in {checked}/{checked} con posizione")
|
|
print(f" [{label}] Spearman dello score fra i venue: mediana {np.median(sp):.4f} "
|
|
f"min {np.min(sp):.4f}")
|
|
print(f" [{label}] ribilanciamenti con gambe DIVERSE: {len(D)}/{tot} "
|
|
f"({len(D)/max(tot,1)*100:.2f}%)")
|
|
if len(D):
|
|
pre = D[D["data"] < pd.Timestamp(T2_END, tz="UTC")]
|
|
print(f" [{label}] di cui NELLA finestra fuori campione ({T2_START}..{T2_END}): "
|
|
f"{len(pre)} — elencati qui sotto; quelli dal 2024 in poi non sono la domanda")
|
|
for _, r in pre.iterrows():
|
|
print(f" fase {int(r['fase'])} {r['data'].date()} "
|
|
f"sovrapposizione {r['overlap']*100:3.0f}% gambe scambiate: {r['gambe']}")
|
|
return D
|
|
|
|
|
|
def gate_flips(PB: pd.DataFrame, PU: pd.DataFrame, ph: int) -> list[tuple]:
|
|
"""Il SECONDO canale, che una scansione di ranking non vede: il gate di dispersione e' BINARIO
|
|
(`disp_i >= percentile espandente`) e quindi DISCONTINUO — due prezzi che differiscono di
|
|
pochi bps possono cadere ai due lati della soglia, e allora uno sleeve resta pienamente
|
|
investito per 10 giorni mentre l'altro sta FLAT. Non e' un cambio di ranking: e' un
|
|
interruttore. Ritorna gli intervalli in cui i due venue non sono d'accordo su acceso/spento."""
|
|
dB: dict = {}
|
|
dU: dict = {}
|
|
X.xsec_engine(PB, phase=ph, detail=dB)
|
|
X.xsec_engine(PU, phase=ph, detail=dU)
|
|
gb = np.abs(dB["W"]).sum(axis=1) > 1e-9
|
|
gu = np.abs(dU["W"]).sum(axis=1) > 1e-9
|
|
idx = PB.index
|
|
flip = np.flatnonzero(gb != gu)
|
|
runs, i0 = [], None
|
|
for j, i in enumerate(flip):
|
|
if i0 is None:
|
|
i0 = i
|
|
if j + 1 == len(flip) or flip[j + 1] != i + 1:
|
|
runs.append((idx[i0], idx[i], int(i - i0 + 1), bool(gb[i0])))
|
|
i0 = None
|
|
return runs
|
|
|
|
|
|
def autopsia(PB: pd.DataFrame, PU: pd.DataFrame, ph: int, D: pd.DataFrame, label: str) -> None:
|
|
"""La fase con la corr piu' bassa NON si riassume, si guarda: una corr di 0,97 o e' un
|
|
ribaltamento di ranking (il guasto che sto cercando) o e' un singolo giorno di rumore su una
|
|
gamba sottile (che non e' un guasto). Sono conclusioni opposte a partire dallo stesso numero."""
|
|
a, b = pair(alive(X.xsec_engine(PU, phase=ph)), alive(X.xsec_engine(PB, phase=ph)))
|
|
g = (a - b)
|
|
top = g.abs().sort_values(ascending=False).head(4)
|
|
dph = D[D["fase"] == ph] if len(D) else D
|
|
runs = gate_flips(PB, PU, ph)
|
|
print(f" autopsia della fase peggiore ({label}, fase {ph}): i 4 giorni di scarto maggiore")
|
|
for t, v in top.items():
|
|
prev = dph[dph["data"] <= t]["data"]
|
|
near = (t - prev.iloc[-1]).days if len(prev) else None
|
|
inflip = [r for r in runs if r[0] <= t <= r[1]]
|
|
# ⚠️ la coda: dopo una discordanza del gate uno dei due sleeve ha 10 giorni di ZERI in
|
|
# piu' nella finestra rv30 del vol-target -> la LEVA dei due resta diversa per ~30 giorni
|
|
# dopo che la discordanza e' finita. Chiamare "rumore di prezzo" un giorno dentro quella
|
|
# coda attribuirebbe al venue un effetto che e' della soglia binaria.
|
|
tail = [r for r in runs if r[1] < t and (t - r[1]).days <= 30]
|
|
if inflip:
|
|
r = inflip[0]
|
|
tag = (f"GATE DISCORDE {r[0].date()}..{r[1].date()}: "
|
|
f"{'USDT investito, USD flat' if r[3] else 'USD investito, USDT flat'}")
|
|
elif tail:
|
|
tag = (f"coda del vol-target: gate discorde fino al {tail[-1][1].date()}, "
|
|
f"{(t - tail[-1][1]).days}g fa -> rv30 diversa, LEVA diversa")
|
|
elif near is not None and near <= XS_CFG["H"]:
|
|
tag = f"ultimo ribilanciamento con gambe diverse {near} giorni prima"
|
|
else:
|
|
tag = "stesse gambe, stesso gate: solo rumore di prezzo"
|
|
print(f" {t.date()} scarto {g.loc[t]*1e4:+8.0f} bps ({tag})")
|
|
print(f" scarto quadratico totale della fase: {float((g**2).sum())**0.5*1e4:.0f} bps; "
|
|
f"i 4 giorni sopra ne spiegano "
|
|
f"{float((top**2).sum())/float((g**2).sum())*100:.0f}%")
|
|
|
|
|
|
def score_at(P: pd.DataFrame, i: int, lookbacks) -> tuple[np.ndarray, np.ndarray]:
|
|
"""Specchio della riga di score del motore (z-score medio sui lookback). Serve per confrontare
|
|
i RANKING fra venue; la sezione [4] verifica che i top-k/bottom-k che ne derivano coincidano
|
|
ESATTAMENTE con quelli scelti dal motore — se lo specchio divergesse, ogni numero di ranking
|
|
misurerebbe la mia riscrittura invece del venue."""
|
|
px = P.values.astype(float)
|
|
elig = np.isfinite(px[i])
|
|
for L in lookbacks:
|
|
elig = elig & np.isfinite(px[i - L])
|
|
idx = np.flatnonzero(elig)
|
|
sc, cnt = np.zeros(len(idx)), 0
|
|
for L in lookbacks:
|
|
r = px[i, idx] / px[i - L, idx] - 1.0
|
|
if r.std() > 0:
|
|
sc += (r - r.mean()) / r.std()
|
|
cnt += 1
|
|
return idx, (sc / cnt if cnt else sc)
|
|
|
|
|
|
# ===========================================================================
|
|
def main() -> None:
|
|
t0 = time.time()
|
|
pd.set_option("display.width", 200)
|
|
print("=" * 100)
|
|
print("DEPEG — il close USDT 2021-2023 puo' aver cambiato il RANKING di XS01-OOS?")
|
|
print(f"XS_CFG (CONGELATO) = {XS_CFG} soglia dichiarata dall'autore: corr >= {CORR_SOGLIA}")
|
|
print("=" * 100)
|
|
|
|
# ------------------------------------------------------------- [0] sanity
|
|
print("\n[0] SANITY — il motore importato e' quello che ha prodotto §21?")
|
|
from src.portfolio.sleeves import _xsec_returns
|
|
off = _xsec_returns()
|
|
rep = X.xsec_engine(X.hl_panel(), phase=0)
|
|
j = pd.concat({"o": off, "r": rep}, axis=1, join="inner").dropna()
|
|
md = float(np.max(np.abs(j["o"] - j["r"])))
|
|
print(f" motore vs sleeve UFFICIALE su HL: n={len(j)} max|diff| = {md:.2e} "
|
|
f"-> {'IDENTICO' if md < 1e-12 else 'DIVERGE — STOP'}")
|
|
if md >= 1e-12:
|
|
return
|
|
|
|
# ------------------------------------------------------- [1] dato USD
|
|
print("\n[1] DATO USD — quanti dei 13 asset di §21 hanno un prezzo in DOLLARI nel 2021-2023?")
|
|
print(f" {'sym':<6}{'venue USD':>11}{'n':>6}{'start':>12}{'end':>12}{'gap':>5}"
|
|
f"{'flat%':>8}{'vol0%':>8} (finestra {T1_START} .. {T1_END})")
|
|
certs = {}
|
|
for s in U13:
|
|
d = fetch_usd_daily(s)
|
|
c = certify_usd(s, d, T1_START, T1_END)
|
|
certs[s] = c
|
|
ven = USD_SRC[s][0] if USD_SRC[s] else "—"
|
|
flag = "" if c["ok"] else " <-- non usabile su questa finestra"
|
|
print(f" {s:<6}{ven:>11}{c['n']:>6}{c['start']:>12}{c['end']:>12}{c['gap']:>5}"
|
|
f"{c['flat']*100:>8.2f}{c['zero_vol']*100:>8.2f}{flag}")
|
|
usabili = [s for s in U13 if certs[s]["ok"]]
|
|
print(f" -> usabili sulla finestra del TEST 1: {len(usabili)}/13 {usabili}")
|
|
print(f" -> ESCLUSI: BNB (nessun venue USD prima del 2025-10 — e' l'asset nativo del venue")
|
|
print(f" sotto esame), NEAR e INJ (Coinbase solo dal 2022-09).")
|
|
print(f" ⚠️ LIMITE DEL TEST, da dire subito: 10 gambe su 13 e finestra che parte dal")
|
|
print(f" {T1_START} (AVAX su Coinbase) -> il TEST 1 NON copre il 2021, che in §21 e'")
|
|
print(f" l'anno piu' forte (+2,14). Copre pero' ESATTAMENTE cio' che l'obiezione nomina:")
|
|
print(f" il depeg di maggio 2022 e FTX. Il 2021 lo copre il TEST 2 (ibrido).")
|
|
|
|
# controllo di ALLINEAMENTO: le barre USD sono sulla stessa griglia di quelle USDT?
|
|
print("\n Controllo di ALLINEAMENTO — se le barre USD e USDT fossero su griglie sfasate,")
|
|
print(" ogni numero sotto sarebbe uno sfasamento di calendario travestito da divergenza")
|
|
print(" di venue. corr dei RITORNI giornalieri, 2024+ (finestra dove esistono entrambi):")
|
|
B24 = bin_panel(U13)
|
|
U24 = usd_panel(U13)
|
|
al, shifted = [], []
|
|
for s in U13:
|
|
if s not in U24.columns or not U24[s].notna().any():
|
|
continue
|
|
k = pd.concat({"u": U24[s], "b": B24[s]}, axis=1, join="inner").dropna()
|
|
k = k[k.index >= pd.Timestamp("2024-01-01", tz="UTC")].pct_change().dropna()
|
|
if len(k) > 200:
|
|
al.append((s, float(k["u"].corr(k["b"]))))
|
|
shifted.append(float(k["u"].shift(1).corr(k["b"]))) # controllo POSITIVO
|
|
print(" " + " ".join(f"{s}:{c:.4f}" for s, c in al))
|
|
lo_al = min(c for _, c in al)
|
|
# ⚠️ Un controllo che non fallisce mai non e' un controllo: il modo di fallire e' uno
|
|
# sfasamento di UNA barra, e va mostrato che il numero se ne accorge. Con la serie USD
|
|
# ritardata di un giorno la corr collassa: e' quella la scala del guasto che sto escludendo.
|
|
print(f" corr minima {lo_al:.4f} | controllo POSITIVO (USD ritardato di 1 giorno): "
|
|
f"corr mediana {np.median(shifted):+.4f}, massima {np.max(shifted):+.4f}")
|
|
if lo_al < 0.95:
|
|
print(" -> SFASAMENTO: i due venue non sono sulla stessa griglia. STOP.")
|
|
return
|
|
print(" -> allineati (uno sfasamento darebbe ~0, non 0,99). Gli asset sotto 0,999")
|
|
print(f" ({', '.join(s for s, c in al if c < 0.999)}) sono solo piu' RUMOROSI in USD")
|
|
print(" (book piu' sottile sul venue USD), non sfasati.")
|
|
|
|
# --------------------------------------------- [2] la divergenza, in DUE pezzi
|
|
print("\n[2] LA DIVERGENZA USD-vs-USDT, scomposta — e il pezzo che conta e' il SECONDO")
|
|
Bp = bin_panel(U10).loc[T1_START:T1_END]
|
|
Up = usd_panel(U10).reindex(Bp.index)
|
|
both = Bp.notna() & Up.notna()
|
|
D = 1e4 * np.log(Up / Bp) # scarto di livello, bps
|
|
D = D.where(both)
|
|
common = D.median(axis=1) # (a) componente COMUNE (il peg + il venue)
|
|
idio = D.sub(common, axis=0) # (b) componente IDIOSINCRATICA (cambia il rango)
|
|
print(f" {len(Bp)} giorni, {len(U10)} asset, {int(both.values.sum())} osservazioni appaiate")
|
|
print(f" (a) COMUNE |mediana per giorno|: med {common.abs().median():7.1f} bps "
|
|
f"p95 {common.abs().quantile(.95):7.1f} max {common.abs().max():7.1f}")
|
|
print(f" (b) IDIOSINCRATICO |scarto de-medianato|: med {idio.abs().stack().median():7.1f} bps "
|
|
f"p95 {idio.abs().stack().quantile(.95):7.1f} max {idio.abs().stack().max():7.1f}")
|
|
print(" -> (a) e' cio' che lo z-score cross-sezionale annulla per costruzione; (b) no.")
|
|
|
|
print(f"\n LA FINESTRA DEL DEPEG {DEPEG[0]} .. {DEPEG[1]} (UST/LUNA; USDT a ~0,95):")
|
|
dm = (D.index >= pd.Timestamp(DEPEG[0], tz="UTC")) & (D.index < pd.Timestamp(DEPEG[1], tz="UTC"))
|
|
print(f" {'giorno':<12}{'comune':>9}" + "".join(f"{s:>8}" for s in U10))
|
|
for t in D.index[dm]:
|
|
print(f" {str(t.date()):<12}{common.loc[t]:>9.0f}" +
|
|
"".join(f"{idio.loc[t, s]:>8.0f}" if np.isfinite(idio.loc[t, s]) else f"{'—':>8}"
|
|
for s in U10))
|
|
print(" (numeri in bps; colonna 'comune' = mediana del giorno, le altre = scarto DOPO")
|
|
print(" averla tolta, cioe' la parte che puo' spostare il ranking)")
|
|
idm = idio[dm].abs().stack()
|
|
print(f" idiosincratico NELLA finestra: med {idm.median():.1f} bps p95 "
|
|
f"{idm.quantile(.95):.1f} max {idm.max():.1f} "
|
|
f"(FUORI: med {idio[~dm].abs().stack().median():.1f}, "
|
|
f"p95 {idio[~dm].abs().stack().quantile(.95):.1f})")
|
|
|
|
print("\n Ma il ranking non legge il LIVELLO: legge i rapporti a 30 e 90 giorni. Divergenza")
|
|
print(" idiosincratica degli STESSI rendimenti che entrano nello score (bps):")
|
|
for L in XS_CFG["lookbacks"]:
|
|
rB = (Bp / Bp.shift(L) - 1.0) * 1e4
|
|
rU = (Up / Up.shift(L) - 1.0) * 1e4
|
|
dR = (rU - rB).where(both)
|
|
dRi = dR.sub(dR.median(axis=1), axis=0)
|
|
w = dRi[dm].abs().stack()
|
|
print(f" r{L:<3d}: idiosincratico med {dRi.abs().stack().median():6.1f} bps "
|
|
f"p95 {dRi.abs().stack().quantile(.95):7.1f} max {dRi.abs().stack().max():8.1f}"
|
|
f" | nel depeg med {w.median():6.1f} max {w.max():8.1f}")
|
|
|
|
# ------------------------------------------- [3] IL TEST 1 — U10, k=5 congelato
|
|
print(f"\n[3] TEST 1 — meccanismo CONGELATO su U10, {T1_START} .. {T1_END}, USD vs USDT")
|
|
print(f" 10 gambe = ESATTAMENTE il minimo del meccanismo (min_assets=10, k=5): nessun")
|
|
print(f" parametro toccato, e il confronto e' appaiato su TUTTO tranne il venue.")
|
|
PB = Bp[U10].dropna()
|
|
PU = Up[U10].dropna()
|
|
idxc = PB.index.intersection(PU.index)
|
|
PB, PU = PB.loc[idxc], PU.loc[idxc]
|
|
print(f" pannello comune: {len(idxc)} giorni, {PB.index[0].date()} .. {PB.index[-1].date()}")
|
|
|
|
rows = []
|
|
for ph in PHASES:
|
|
a = alive(X.xsec_engine(PU, phase=ph))
|
|
b = alive(X.xsec_engine(PB, phase=ph))
|
|
a, b = pair(a, b)
|
|
rows.append(dict(ph=ph, corr=float(a.corr(b)), sh_usd=sh(a), sh_usdt=sh(b),
|
|
d=sh(a) - sh(b), dd_usd=dd(a), dd_usdt=dd(b), n=len(a)))
|
|
R = pd.DataFrame(rows)
|
|
print(f" {'fase':>5}{'corr':>9}{'Sh USD':>9}{'Sh USDT':>9}{'dSharpe':>10}"
|
|
f"{'DD USD':>9}{'DD USDT':>9}")
|
|
for _, r in R.iterrows():
|
|
print(f" {int(r['ph']):>5}{r['corr']:>9.4f}{r['sh_usd']:>9.2f}{r['sh_usdt']:>9.2f}"
|
|
f"{r['d']:>+10.3f}{r['dd_usd']*100:>8.1f}%{r['dd_usdt']*100:>8.1f}%")
|
|
print(f" {'MEDIANA':>5}{R['corr'].median():>9.4f}{R['sh_usd'].median():>9.2f}"
|
|
f"{R['sh_usdt'].median():>9.2f}{R['d'].median():>+10.3f}"
|
|
f"{R['dd_usd'].median()*100:>8.1f}%{R['dd_usdt'].median()*100:>8.1f}%")
|
|
print(f" corr MINIMA fra le 10 fasi: {R['corr'].min():.4f} (fase {int(R.loc[R['corr'].idxmin(),'ph'])})"
|
|
f" | soglia dichiarata {CORR_SOGLIA} -> "
|
|
f"{'PASS' if R['corr'].min() >= CORR_SOGLIA else 'FAIL'}")
|
|
print(f" dSharpe appaiato (USD - USDT): mediana {R['d'].median():+.3f} "
|
|
f"banda [{R['d'].min():+.3f},{R['d'].max():+.3f}] "
|
|
f"fasi in cui USD e' MEGLIO {(R['d'] > 0).sum()}/{len(R)}")
|
|
print(f" ⚠️ la statistica e' la MEDIANA DELLE DIFFERENZE APPAIATE, non la differenza delle")
|
|
print(f" mediane (lezione 26/07: quest'ultima confronta fasi diverse e puo' ribaltare).")
|
|
|
|
# quanto di §21 riproduce questo sottoinsieme? (o si misura l'universo, non il venue)
|
|
p13 = bin_panel(U13)[U13].dropna()
|
|
s13_w = win(alive(X.xsec_engine(p13, phase=0)), T1_START, T1_END)
|
|
s10_w = win(alive(X.xsec_engine(PB, phase=0)), T1_START, T1_END)
|
|
print(f"\n Contesto obbligatorio — quanto di §21 vive in questo sottoinsieme (Binance, fase 0,")
|
|
print(f" stessa finestra): U13 Sh {sh(s13_w):+.2f} | U10 Sh {sh(s10_w):+.2f}")
|
|
print(f" -> il TEST 1 giudica il VENUE su U10; NON e' una replica del titolo di §21.")
|
|
|
|
# ------------------------------------------------ [4] i RANKING, non i P&L
|
|
print("\n[4] IL CANALE DEL DANNO — cambia il RANKING? (e' cio' che la strategia legge)")
|
|
print(" Un P&L simile puo' nascere da due ranking diversi che si compensano: la domanda")
|
|
print(" diretta e' se le GAMBE SCELTE cambiano. Scansione su tutte e 10 le fasi.")
|
|
D1 = ranking_scan(PB, PU, PHASES, "TEST 1 / U10")
|
|
if len(D1):
|
|
ind = D1[(D1["data"] >= pd.Timestamp(DEPEG[0], tz="UTC")) &
|
|
(D1["data"] < pd.Timestamp(DEPEG[1], tz="UTC"))]
|
|
print(f" di cui dentro la finestra del depeg: {len(ind)}")
|
|
|
|
# ---------------------- [4b] il SECONDO canale: il gate binario, e l'attribuzione
|
|
print("\n[4b] IL GATE DI DISPERSIONE E' UN INTERRUTTORE — e una scansione di ranking non lo")
|
|
print(" vede. `disp_i >= percentile espandente` e' una soglia: pochi bps di differenza di")
|
|
print(" prezzo possono cadere ai due lati, e per 10 giorni uno sleeve e' pieno e l'altro")
|
|
print(" e' FLAT. E' l'unico modo in cui una differenza di venue microscopica puo'")
|
|
print(" produrre una differenza di P&L macroscopica.")
|
|
for label_, Pb_, Pu_ in (("TEST 1 / U10", PB, PU),):
|
|
tot_fl = 0
|
|
for ph in PHASES:
|
|
for a_, b_, nd, bfirst in gate_flips(Pb_, Pu_, ph):
|
|
tot_fl += 1
|
|
print(f" [{label_}] fase {ph}: {a_.date()} .. {b_.date()} ({nd}g) — "
|
|
f"{'USDT investito / USD FLAT' if bfirst else 'USD investito / USDT FLAT'}")
|
|
if tot_fl == 0:
|
|
print(f" [{label_}] nessuna discordanza del gate su 10 fasi")
|
|
else:
|
|
print(f" [{label_}] {tot_fl} intervalli di discordanza su 10 fasi")
|
|
|
|
print("\n ATTRIBUZIONE — stesso confronto con il gate SPENTO su ENTRAMBI i venue")
|
|
print(" (diagnostica, NON una proposta di cambiare il meccanismo: serve a separare")
|
|
print(" 'il prezzo e' diverso' da 'la soglia binaria amplifica una differenza minuscola'):")
|
|
cg = []
|
|
for ph in PHASES:
|
|
a_, b_ = pair(alive(X.xsec_engine(PU, phase=ph, disp_pct=0)),
|
|
alive(X.xsec_engine(PB, phase=ph, disp_pct=0)))
|
|
cg.append(float(a_.corr(b_)))
|
|
print(f" [TEST 1] corr con gate SPENTO: mediana {np.median(cg):.4f} minima {np.min(cg):.4f}"
|
|
f" (col gate acceso: mediana {R['corr'].median():.4f}, minima {R['corr'].min():.4f})")
|
|
|
|
# ------------------------------- [5] TEST 2 — U13 ibrido, finestra INTERA di §21
|
|
print(f"\n[5] TEST 2 — U13 IBRIDO (USD dove esiste, USDT altrove), {T2_START} .. {T2_END}")
|
|
print(" Domanda operativa: sostituendo TUTTO il prezzo in dollari che esiste, il titolo")
|
|
print(" di §21 (mediana di fase +1,12 fuori campione) si muove?")
|
|
HB, meta = hybrid_panel(U13)
|
|
print(" prima data USD per asset: " + " ".join(f"{s}:{meta[s]}" for s in U13))
|
|
PBh = p13
|
|
PUh = HB[U13].dropna()
|
|
ic = PBh.index.intersection(PUh.index)
|
|
PBh, PUh = PBh.loc[ic], PUh.loc[ic]
|
|
rows2 = []
|
|
for ph in PHASES:
|
|
a = win(alive(X.xsec_engine(PUh, phase=ph)), T2_START, T2_END)
|
|
b = win(alive(X.xsec_engine(PBh, phase=ph)), T2_START, T2_END)
|
|
a, b = pair(a, b)
|
|
rows2.append(dict(ph=ph, corr=float(a.corr(b)), sh_usd=sh(a), sh_usdt=sh(b),
|
|
d=sh(a) - sh(b), dd_usd=dd(a), dd_usdt=dd(b)))
|
|
R2 = pd.DataFrame(rows2)
|
|
print(f" {'fase':>5}{'corr':>9}{'Sh IBRIDO':>11}{'Sh USDT':>10}{'dSharpe':>10}"
|
|
f"{'DD IBR':>9}{'DD USDT':>9}")
|
|
for _, r in R2.iterrows():
|
|
print(f" {int(r['ph']):>5}{r['corr']:>9.4f}{r['sh_usd']:>11.2f}{r['sh_usdt']:>10.2f}"
|
|
f"{r['d']:>+10.3f}{r['dd_usd']*100:>8.1f}%{r['dd_usdt']*100:>8.1f}%")
|
|
print(f" {'MEDIANA':>5}{R2['corr'].median():>9.4f}{R2['sh_usd'].median():>11.2f}"
|
|
f"{R2['sh_usdt'].median():>10.2f}{R2['d'].median():>+10.3f}"
|
|
f"{R2['dd_usd'].median()*100:>8.1f}%{R2['dd_usdt'].median()*100:>8.1f}%")
|
|
print(f" corr minima {R2['corr'].min():.4f} -> "
|
|
f"{'PASS' if R2['corr'].min() >= CORR_SOGLIA else 'FAIL'} (soglia {CORR_SOGLIA})")
|
|
print(f" 📌 IL NUMERO DI TESTA DI §21, RICALCOLATO IN DOLLARI: mediana di fase fuori")
|
|
print(f" campione {R2['sh_usdt'].median():+.2f} (USDT, replica) -> "
|
|
f"{R2['sh_usd'].median():+.2f} (IBRIDO USD).")
|
|
|
|
# differenza appaiata con la macchineria del progetto (stesso gate di §21)
|
|
dlt = A.anchor_luck_delta(
|
|
lambda ph: win(alive(X.xsec_engine(PUh, phase=ph)), T2_START, T2_END),
|
|
lambda ph: win(alive(X.xsec_engine(PBh, phase=ph)), T2_START, T2_END),
|
|
PHASES, metric=sh)
|
|
print(f" anchor_luck_delta (IBRIDO - USDT): mediana appaiata {dlt['median_paired']:+.3f} "
|
|
f"[{dlt['lo']:+.3f},{dlt['hi']:+.3f}], fasi con IBRIDO>USDT "
|
|
f"{dlt['n_positive']}/{dlt['n_anchors']}")
|
|
print("\n E il ranking, sull'ibrido (la fase con la corr piu' bassa va GUARDATA, non")
|
|
print(" riassunta: una corr di 0,97 su una fase o e' un ribaltamento vero o e' un giunto):")
|
|
D2 = ranking_scan(PBh, PUh, PHASES, "TEST 2 / U13-IBRIDO")
|
|
print("\n Discordanze del GATE binario sull'ibrido (finestra fuori campione):")
|
|
nfl = 0
|
|
for ph in PHASES:
|
|
for a_, b_, nd, bfirst in gate_flips(PBh, PUh, ph):
|
|
if a_ >= pd.Timestamp(T2_END, tz="UTC"):
|
|
continue
|
|
nfl += 1
|
|
print(f" fase {ph}: {a_.date()} .. {b_.date()} ({nd}g) — "
|
|
f"{'USDT investito / USD FLAT' if bfirst else 'USD investito / USDT FLAT'}")
|
|
print(f" totale {nfl} intervalli su 10 fasi (su ~204 ribilanciamenti per fase)")
|
|
cg2 = []
|
|
for ph in PHASES:
|
|
a_, b_ = pair(win(alive(X.xsec_engine(PUh, phase=ph, disp_pct=0)), T2_START, T2_END),
|
|
win(alive(X.xsec_engine(PBh, phase=ph, disp_pct=0)), T2_START, T2_END))
|
|
cg2.append(float(a_.corr(b_)))
|
|
print(f" ATTRIBUZIONE [TEST 2] corr con gate SPENTO: mediana {np.median(cg2):.4f} "
|
|
f"minima {np.min(cg2):.4f} (col gate acceso: mediana {R2['corr'].median():.4f}, "
|
|
f"minima {R2['corr'].min():.4f})")
|
|
|
|
# ------------------------------- [5b] le gambe che NESSUN venue USD puo' controllare
|
|
print("\n[5b] LE TRE GAMBE NON CONTROLLABILI — quanto del risultato di §21 ci passa?")
|
|
print(" BNB e' il token nativo del venue sotto esame e NON esiste in USD nel 2021-23;")
|
|
print(" NEAR e INJ hanno un prezzo USD solo dal 2022-09. Se il titolo di §21 vivesse su")
|
|
print(" di loro, questo falsificatore non avrebbe potuto vedere niente, e andrebbe detto.")
|
|
base_b = A.anchor_luck_band(
|
|
lambda ph: win(alive(X.xsec_engine(PBh, phase=ph)), T2_START, T2_END),
|
|
PHASES, canonical=0, metric=sh)
|
|
print(f" base U13 (Binance, fuori campione, mediana di fase): {base_b['median']:+.2f}")
|
|
for a_ in ("BNB", "NEAR", "INJ"):
|
|
sub = p13[[c for c in U13 if c != a_]].dropna()
|
|
bb = A.anchor_luck_band(
|
|
lambda ph, sub=sub: win(alive(X.xsec_engine(sub, phase=ph, min_assets=10)),
|
|
T2_START, T2_END),
|
|
PHASES, canonical=0, metric=sh)
|
|
print(f" senza {a_:<5s}: mediana di fase {bb['median']:+.2f} "
|
|
f"({bb['median']-base_b['median']:+.2f}) banda [{bb['lo']:+.2f},{bb['hi']:+.2f}]")
|
|
print(" (leave-one-out a 12 gambe: il meccanismo congelato regge, min_assets=10)")
|
|
|
|
# ---------------------------------------------------- [6] IL CASO PEGGIORE
|
|
print("\n[6] IL CASO PEGGIORE — non la media: dove i due venue divergono di piu'?")
|
|
print(f" {'anno':>6}" + "".join(f"{k:>12}" for k in
|
|
("corr T1", "dSh T1", "corr T2", "dSh T2")))
|
|
for y in (2021, 2022, 2023):
|
|
a1 = b1 = a2 = b2 = None
|
|
cs1, ds1, cs2, ds2 = [], [], [], []
|
|
for ph in PHASES:
|
|
a1 = win(alive(X.xsec_engine(PU, phase=ph)), f"{y}-01-01", f"{y+1}-01-01")
|
|
b1 = win(alive(X.xsec_engine(PB, phase=ph)), f"{y}-01-01", f"{y+1}-01-01")
|
|
if len(a1) > 60 and len(b1) > 60:
|
|
a1, b1 = pair(a1, b1)
|
|
cs1.append(float(a1.corr(b1))); ds1.append(sh(a1) - sh(b1))
|
|
a2 = win(alive(X.xsec_engine(PUh, phase=ph)), f"{y}-01-01", f"{y+1}-01-01")
|
|
b2 = win(alive(X.xsec_engine(PBh, phase=ph)), f"{y}-01-01", f"{y+1}-01-01")
|
|
if len(a2) > 60 and len(b2) > 60:
|
|
a2, b2 = pair(a2, b2)
|
|
cs2.append(float(a2.corr(b2))); ds2.append(sh(a2) - sh(b2))
|
|
f1 = f"{np.median(cs1):.4f}" if cs1 else "—"
|
|
g1 = f"{np.median(ds1):+.3f}" if ds1 else "—"
|
|
f2 = f"{np.median(cs2):.4f}" if cs2 else "—"
|
|
g2 = f"{np.median(ds2):+.3f}" if ds2 else "—"
|
|
print(f" {y:>6}{f1:>12}{g1:>12}{f2:>12}{g2:>12}")
|
|
worst1 = R.loc[R["corr"].idxmin()]
|
|
worst2 = R2.loc[R2["corr"].idxmin()]
|
|
wd1 = R.loc[R["d"].abs().idxmax()]
|
|
wd2 = R2.loc[R2["d"].abs().idxmax()]
|
|
print(f" peggior FASE per corr: T1 fase {int(worst1['ph'])} corr {worst1['corr']:.4f} | "
|
|
f"T2 fase {int(worst2['ph'])} corr {worst2['corr']:.4f}")
|
|
print(f" peggior FASE per dSharpe: T1 fase {int(wd1['ph'])} {wd1['d']:+.3f} | "
|
|
f"T2 fase {int(wd2['ph'])} {wd2['d']:+.3f}")
|
|
autopsia(PB, PU, int(worst1["ph"]), D1, "TEST 1")
|
|
autopsia(PBh, PUh, int(worst2["ph"]), D2, "TEST 2")
|
|
|
|
st = idio.abs().stack().sort_values(ascending=False)
|
|
print(" le 8 divergenze IDIOSINCRATICHE piu' grandi della finestra del TEST 1 (bps):")
|
|
for (t, s), v in st.head(8).items():
|
|
indep = "DEPEG" if pd.Timestamp(DEPEG[0], tz="UTC") <= t < pd.Timestamp(DEPEG[1], tz="UTC") else ""
|
|
print(f" {str(t.date()):<12}{s:<6}{v:8.0f} bps (comune quel giorno "
|
|
f"{common.loc[t]:+.0f} bps) {indep}")
|
|
print(" -> le peggiori NON cadono nel depeg e sono quasi tutte AVAX nelle settimane subito")
|
|
print(" dopo la sua quotazione su Coinbase: book sottile, non contaminazione da")
|
|
print(" stablecoin. Due cause diverse e due implicazioni diverse.")
|
|
|
|
# --------- il caso peggiore su TUTTO il campione, non solo sulla finestra del test
|
|
print("\n ⚠️ E ORA LA DOMANDA GIUSTA, allargata: dove divergono di piu' i due venue in")
|
|
print(" TUTTO il campione 2021-2026? (cercare il caso peggiore solo dentro la finestra")
|
|
print(" che si sta difendendo e' un modo di non trovarlo)")
|
|
have = [s for s in U13 if USD_SRC[s] is not None]
|
|
Bf = bin_panel(have)
|
|
Uf = usd_panel(have).reindex(Bf.index)
|
|
bo = Bf.notna() & Uf.notna()
|
|
Df = (1e4 * np.log(Uf / Bf)).where(bo)
|
|
idf = Df.sub(Df.median(axis=1), axis=0)
|
|
worst_day = idf.abs().max(axis=1).sort_values(ascending=False)
|
|
print(f" {'giorno':<12}{'|idio| max':>11}{'asset':>7}{'comune':>9} finestra")
|
|
for t in worst_day.head(6).index:
|
|
s = idf.loc[t].abs().idxmax()
|
|
w = "fuori campione" if t < pd.Timestamp(T2_END, tz="UTC") else "scoperta 2024+"
|
|
print(f" {str(t.date()):<12}{idf.loc[t, s]:>11.0f}{s:>7}{Df.loc[t].median():>9.0f} {w}")
|
|
tw = worst_day.index[0]
|
|
print(f" il giorno peggiore in assoluto e' il {tw.date()}: scarto per asset (bps)")
|
|
print(" " + " ".join(f"{s}:{idf.loc[tw, s]:.0f}" for s in have
|
|
if np.isfinite(idf.loc[tw, s])))
|
|
print(" 📌 E' un fatto che va detto per intero: la divergenza idiosincratica PUO'")
|
|
print(" esplodere — qui di due ordini di grandezza — ma e' successo in una CASCATA DI")
|
|
print(" LIQUIDAZIONI sulle coppie /USDT, non in un depeg, e cade nella finestra di")
|
|
print(" SCOPERTA (2024+, dove lo sleeve gira su Hyperliquid), non nel fuori campione.")
|
|
print(" Il meccanismo temuto dall'obiezione e' REALE; non e' accaduto nel 2021-2023.")
|
|
|
|
# il giorno peggiore: dove il P&L dei due sleeve si stacca di piu'
|
|
a0 = alive(X.xsec_engine(PU, phase=0)); b0 = alive(X.xsec_engine(PB, phase=0))
|
|
a0, b0 = pair(a0, b0)
|
|
gap = (a0 - b0)
|
|
print(f" scarto GIORNALIERO fra i due sleeve (fase 0): med "
|
|
f"{gap.abs().median()*1e4:.1f} bps p99 {gap.abs().quantile(.99)*1e4:.1f} bps "
|
|
f"max {gap.abs().max()*1e4:.1f} bps il {gap.abs().idxmax().date()}")
|
|
cum = (1 + a0).cumprod().iloc[-1] / (1 + b0).cumprod().iloc[-1] - 1
|
|
print(f" divario CUMULATO su tutta la finestra del TEST 1: {cum*100:+.2f}% "
|
|
f"(equity USD vs equity USDT)")
|
|
|
|
# --------------------------------------------------------------- [7] gate
|
|
print("\n[7] GATE")
|
|
print(f" soglia di venue (dichiarata dall'autore PRIMA, non da me): corr >= {CORR_SOGLIA}")
|
|
print(f" TEST 1 U10 congelato : corr mediana {R['corr'].median():.4f}, minima "
|
|
f"{R['corr'].min():.4f} -> {'PASS' if R['corr'].min() >= CORR_SOGLIA else 'FAIL'}")
|
|
print(f" TEST 2 U13 ibrido : corr mediana {R2['corr'].median():.4f}, minima "
|
|
f"{R2['corr'].min():.4f} -> {'PASS' if R2['corr'].min() >= CORR_SOGLIA else 'FAIL'}"
|
|
f" (una fase su 10; col gate spento minima {np.min(cg2):.4f} = PASS)")
|
|
print(f" ⚠️ il TEST 2 e' MIO, non quello dichiarato: e' piu' severo per costruzione")
|
|
print(f" (le gambe cambiano venue in date diverse) e la sua unica fase sotto soglia")
|
|
print(f" e' attribuita al gate binario, non al prezzo.")
|
|
print(f" riferimento 2024+ di §21 (Binance vs Hyperliquid): 0,9991 / dSharpe -0,025")
|
|
su = alive(X.xsec_engine(PUh, phase=0))
|
|
mg = A.marginal_vs_tp01(win(su, T2_START, T2_END))
|
|
print(f" marginal_vs_tp01 sullo sleeve IBRIDO fuori campione: {mg.get('marginal_verdict')} "
|
|
f"(corr {mg.get('corr_full')}, is_hedge {mg.get('is_hedge')}, "
|
|
f"insample_edge {mg.get('has_insample_edge')})")
|
|
imp = A.implausible_sharpe(win(su, T2_START, T2_END))
|
|
print(f" implausible_sharpe (ibrido OOS): {imp['implausible']} Sh {imp.get('sharpe'):+.2f} "
|
|
f"perdite su barre attive {imp.get('loss_frac', float('nan'))*100:.1f}%")
|
|
print(" causalita': NON RI-GIRATA — il motore e' importato invariato da r0822b_xs01_oos.py,")
|
|
print(" che la verifica (prezzi futuri randomizzati -> max|diff| = 0). Cambiare il venue")
|
|
print(" cambia i dati, non l'ordine temporale in cui il motore li legge.")
|
|
print(" deflated_sharpe: NON PERTINENTE — qui non si SELEZIONA una cella, si confronta due")
|
|
print(" volte lo STESSO meccanismo su due fonti di prezzo. Nessun trial nuovo di strategia.")
|
|
print(" null de-levering: NON PERTINENTE (nessun claim di 'meno drawdown').")
|
|
print(" anchor: girato per costruzione — ogni numero sopra e' su tutte e 10 le fasi.")
|
|
|
|
# ------------------------------------------------------------ [8] verdetto
|
|
print("\n[8] VERDETTO")
|
|
print(f" Il TEST DICHIARATO (meccanismo congelato, stesso sottoinsieme, stessa finestra,")
|
|
print(f" USD contro USDT) PASSA: corr mediana {R['corr'].median():.4f}, minima "
|
|
f"{R['corr'].min():.4f} >= {CORR_SOGLIA}, dSharpe appaiato {R['d'].median():+.3f}.")
|
|
print(f" Il titolo di §21 ricalcolato in dollari si muove di {R2['sh_usd'].median()-R2['sh_usdt'].median():+.2f} "
|
|
f"({R2['sh_usdt'].median():+.2f} -> {R2['sh_usd'].median():+.2f} di mediana di fase).")
|
|
print(f" Nella finestra del depeg la componente idiosincratica sale (med {idm.median():.1f} bps "
|
|
f"contro {idio[~dm].abs().stack().median():.1f}) ma resta due ordini di grandezza sotto")
|
|
print(f" la vol giornaliera di un alt, e ZERO ribilanciamenti cambiano gambe li' dentro.")
|
|
print(f" L'unica corr sotto soglia (TEST 2, fase 2: {R2['corr'].min():.4f}) e' attribuita:")
|
|
print(f" col gate di dispersione SPENTO la minima diventa {np.min(cg2):.4f} -> non e' il")
|
|
print(f" prezzo, e' la soglia BINARIA che amplifica pochi bps in 10 giorni di flat.")
|
|
print( " -> IL RISULTATO XS01-OOS SOPRAVVIVE al controllo di venue.")
|
|
print( " Cio' che NON e' stato controllato, e va citato insieme al verdetto: BNB non ha un")
|
|
print( " prezzo USD nel 2021-23 (e' il token nativo del venue sotto esame), e toglierlo")
|
|
print( " costa -0.75 di mediana di fase. Il test copre 10-12 gambe su 13, non 13.")
|
|
print(f" E il caso peggiore di divergenza dell'INTERO campione ({tw.date()}, "
|
|
f"{idf.loc[tw].abs().max():.0f} bps su una gamba)")
|
|
print( " dimostra che il meccanismo temuto e' reale: semplicemente non e' accaduto nella")
|
|
print( " finestra fuori campione. Non e' 'non puo' succedere', e' 'non e' successo li''.")
|
|
|
|
print(f"\n[fine] {time.time()-t0:.1f}s")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|