L14 — Venti strategie senza vantaggio e il correttore per test multipli

from math import erf, sqrt

import matplotlib.pyplot as plt
import numpy as np

from cvbook import seed_for
from cvbook.dati import carica
from cvbook.regole import compra_e_tieni, esegui, rottura, sopra_media

ALFA = 0.05


def quantile_normale(p: float) -> float:
    basso, alto = -10.0, 10.0
    for _ in range(200):
        mezzo = (basso + alto) / 2
        if 0.5 * (1 + erf(mezzo / sqrt(2))) < p:
            basso = mezzo
        else:
            alto = mezzo
    return (basso + alto) / 2

IDEE = 20          # PROVA / TRY: 500 (vedi esercizio 2)
OSSERVAZIONI = 400

rng = np.random.default_rng(seed_for("lab-metodo-venti"))
soglia = quantile_normale(1 - ALFA)

statistiche = []
for _ in range(IDEE):
    campione = rng.normal(0.0, 0.03, OSSERVAZIONI)  # vantaggio ESATTAMENTE zero
    statistiche.append(campione.mean() / (campione.std(ddof=1) / np.sqrt(OSSERVAZIONI)))

statistiche = np.array(statistiche)
passate = statistiche > soglia

with avvio.figura("schermo"):
    fig, ax = plt.subplots(figsize=(9, 4))
    ax.bar(np.arange(1, IDEE + 1), statistiche)
    ax.axhline(soglia, linestyle="--", linewidth=1.5,
               label=f"soglia del test standard ({soglia:.2f})")
    ax.set_xlabel("Idea provata")
    ax.set_ylabel("Statistica t")
    ax.legend()
    plt.show()

print(f"{int(passate.sum())} idee su {IDEE} hanno superato il test.")
print("Nessuna di esse aveva un vantaggio: era zero, messo li' da noi.")

print(f"{'idee provate':>13s} {'prob. che almeno una passi':>28s}")
for n in (1, 5, 10, 20, 50, 100):
    print(f"{n:13d} {1 - (1 - ALFA) ** n:27.1%}")

print("\nChi prova cento configurazioni TROVERA' qualcosa che supera il test. "
      "E non sapra' di aver trovato niente, perche' il risultato finale ha "
      "esattamente lo stesso aspetto di una scoperta vera.")

SERIE = ["btcusdt", "ethusdt", "solusdt"]
REGOLE = {  # PROVA / TRY: aggiungi una regola (vedi esercizio 1)
    "sopra la media 50": lambda p: sopra_media(p, 50),
    "sopra la media 100": lambda p: sopra_media(p, 100),
    "sopra la media 200": lambda p: sopra_media(p, 200),
    "rottura a 20": lambda p: rottura(p, 20),
    "rottura a 55": lambda p: rottura(p, 55),
}
PARTENZE = [0, 365, 730]  # PROVA / TRY: aggiungi una data d'inizio (esercizio 1)

risultati = []
for nome_serie in SERIE:
    p_intero = carica(nome_serie).sort("data")["chiusura"].to_numpy()
    for nome_regola, regola in REGOLE.items():
        for partenza in PARTENZE:
            p = p_intero[partenza:]
            if len(p) < 400:
                continue
            finale = esegui(p, regola(p), costo=0.0012)["finale"]
            # Il denominatore passa dallo stesso motore delle regole, con gli
            # stessi costi: `p[-1] / p[0]` faceva entrare il compra-e-tieni
            # senza pagare il proprio ingresso mentre ogni regola pagava.
            riferimento = esegui(p, compra_e_tieni(p), costo=0.0012)["finale"]
            risultati.append((nome_serie, nome_regola, partenza,
                              finale, finale / riferimento))

print(f"combinazioni provate: {len(risultati)}  "
      f"({len(SERIE)} serie × {len(REGOLE)} regole × {len(PARTENZE)} date d'inizio)\n")

rapporti = np.array([r[4] for r in risultati])
migliore = risultati[int(np.argmax(rapporti))]
print(f"la migliore: {migliore[1]} su {migliore[0]} partendo dal giorno {migliore[2]}")
print(f"  → {migliore[3]:.2f}x, cioe' {migliore[4]:.2f} volte il compra-e-tieni\n")
print(f"quante battono il compra-e-tieni: {int((rapporti > 1).sum())} su {len(rapporti)} "
      f"({(rapporti > 1).mean():.0%})")
print(f"mediana del rapporto: {np.median(rapporti):.2f}")
print("\nSe pubblicassi solo la prima riga, non avrei mentito su nessun numero. "
      "Avrei omesso il denominatore.")

def soglia_corretta(tentativi: int, alfa: float = ALFA) -> float:
    """Correzione conservativa: il rischio accettato si divide per i tentativi."""
    return quantile_normale(1 - alfa / tentativi)


TUOI_TENTATIVI = len(risultati)  # ← PROVA / TRY: metti il numero dal TUO registro delle ipotesi
TUA_STATISTICA = 2.4             # ← PROVA / TRY: la statistica t del TUO risultato migliore

print(f"tentativi dichiarati: {TUOI_TENTATIVI}")
print(f"soglia non corretta:  {quantile_normale(1 - ALFA):.2f}")
print(f"soglia corretta:      {soglia_corretta(TUOI_TENTATIVI):.2f}")
print(f"\nil tuo {TUA_STATISTICA:.2f} " +
      ("SUPERA" if TUA_STATISTICA > soglia_corretta(TUOI_TENTATIVI) else "NON supera") +
      " la soglia corretta.")

MODELLO = """\
data:                2026-08-16
ipotesi:             la rottura del massimo a N giorni produce un vantaggio su BTC
successo se:         supera il 95esimo percentile del metro del caso, con costi 0,25%
fallimento se:       resta sotto, oppure il risultato dipende da N in modo instabile
varianti previste:   24 valori di N, un solo mercato
--- esito ---
risultato:
tentativi effettivi:
note:
"""
print(MODELLO)
print("Dopo sei mesi quel file ti dira' una cosa che nessun backtest puo' dirti: "
      "QUANTE idee hai provato in tutto. E quel numero e' il moltiplicatore da "
      "applicare a ogni tuo risultato positivo.")