"""Models, strategies, accounting and statistical tests for the HRT paradox paper. Strategies decide a position w_t in [0, 1] (long or cash, no leverage) at the close of day t, using only data up to t; the position earns the return of day t+1, minus costs. hold buy and hold sma trend baseline: long when SMA(50) > SMA(200) bayes Bayesian drift: P(mu > 0 | data) from a discounted Normal-Inverse-Gamma model mc one-step Bayesian Monte Carlo planning: sample 20-day futures from the posterior, pick the position with the highest expected CRRA utility net of trading costs mcts Bayes-adaptive Monte Carlo tree search: same model and utility, but the agent can rebalance every 5 days within the 20-day horizon, reacting to whether the price went down, sideways or up (UCT with root sampling and common random numbers at the root) tree the same 4-step decision tree searched exhaustively by backward induction on a fixed scenario set (the limit that MCTS approximates) All hyperparameters are fixed here, before any run on the data they are applied to. """ import math from pathlib import Path import numpy as np import pandas as pd from scipy import stats ROOT = Path(__file__).resolve().parent.parent DATA, FIG, OUT = ROOT / "data", ROOT / "fig", ROOT / "out" # periods per year, evaluation window ("five months"), cost per unit of turnover, # prior daily volatility, warm-up length CRYPTO = dict(ppy=365, window=152, cost=0.0015, s0=0.04, warmup=365, cls="crypto") ETF = dict(ppy=252, window=105, cost=0.0005, s0=0.012, warmup=252, cls="etf") ASSETS = dict(btc=CRYPTO, eth=CRYPTO, bnb=CRYPTO, xrp=CRYPTO, ltc=CRYPTO, ada=CRYPTO, spy=ETF, qqq=ETF, gld=ETF, tlt=ETF) HALF_LIFE = 90 # discounting of old data, in observations ENTER, EXIT = 0.55, 0.45 KAPPA0, ALPHA0 = 10.0, 2.0 MC_PATHS, MC_HORIZON, GAMMA = 2000, 20, 3.0 MC_GRID = [0.0, 0.25, 0.5, 0.75, 1.0] TREE_SIMS, TREE_STEP, TREE_DEPTH, UCT_C = 1600, 5, 4, 1.0 # 4 decisions x 5 days = 20 N_SHIFTS = 5000 SEED = 2026 LABEL = dict(hold="Buy and hold", sma="SMA 50/200", bayes="Bayesian drift", mc="Bayesian MC (1 step)", tree="Bayesian tree (4 steps)", mcts="Bayes-adaptive MCTS", vol="Volatility timing", const="Constant mix") def load(name): df = pd.read_csv(DATA / f"{name}.csv", parse_dates=["date"]).set_index("date") return df["close"] def log_returns(price): return np.log(price).diff().fillna(0.0).to_numpy() def rf_daily(dates, ppy): """Risk-free rate per period on the given dates: 13-week US Treasury bill yield (Yahoo ^IRX, annual percent), carried forward to days without a quote.""" y = load("irx") y = y.reindex(y.index.union(pd.DatetimeIndex(dates))).ffill().bfill() y = y.reindex(pd.DatetimeIndex(dates)).to_numpy() return (1.0 + y / 100.0) ** (1.0 / ppy) - 1.0 # ---------- Bayesian model ---------- def posterior_path(r, s0, half_life=HALF_LIFE, kappa0=KAPPA0): """Discounted NIG posterior after each day: columns mu_n, kappa_n, alpha_n, beta_n.""" d = 0.5 ** (1.0 / half_life) b0 = ALPHA0 * s0 * s0 n = s1 = s2 = 0.0 out = np.empty((len(r), 4)) for t, x in enumerate(r): n, s1, s2 = d * n + 1.0, d * s1 + x, d * s2 + x * x kn = kappa0 + n xbar = s1 / n out[t, 0] = s1 / kn # prior mean is zero out[t, 1] = kn out[t, 2] = ALPHA0 + n / 2.0 out[t, 3] = b0 + 0.5 * max(s2 - s1 * s1 / n, 0.0) + kappa0 * n * xbar * xbar / (2.0 * kn) return out def prob_positive(post): mn, kn, an, bn = post.T return stats.t.cdf(mn / np.sqrt(bn / (an * kn)), df=2.0 * an) def predictive_vol(post): """Posterior mean of sigma (daily).""" return np.sqrt(post[:, 3] / np.maximum(post[:, 2] - 1.0, 0.5)) # ---------- strategies ---------- def sma_weights(price): fast, slow = price.rolling(50).mean(), price.rolling(200).mean() return (fast > slow).astype(float).to_numpy() def bayes_weights(post, enter=ENTER, exit_=None): exit_ = 1.0 - enter if exit_ is None else exit_ p = prob_positive(post) w, cur = np.zeros(len(p)), 0.0 for t in range(len(p)): if cur == 0.0 and p[t] > enter: cur = 1.0 elif cur == 1.0 and p[t] < exit_: cur = 0.0 w[t] = cur return w def crra(wealth, gamma=GAMMA): return (np.maximum(wealth, 1e-6) ** (1.0 - gamma) - 1.0) / (1.0 - gamma) def mc_weights(post, cost, seed, start=0, gamma=GAMMA): rng = np.random.default_rng(seed) grid = np.array(MC_GRID) w, cur = np.zeros(len(post)), 0.0 for t in range(start, len(post)): mn, kn, an, bn = post[t] sig2 = bn / rng.gamma(an, 1.0, MC_PATHS) # sigma^2 ~ InvGamma mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(MC_PATHS) R = MC_HORIZON * mu + np.sqrt(MC_HORIZON * sig2) * rng.standard_normal(MC_PATHS) wealth = 1.0 + grid[None, :] * np.expm1(R)[:, None] - cost * np.abs(grid - cur)[None, :] cur = grid[np.argmax(crra(wealth, gamma).mean(axis=0))] w[t] = cur return w def mcts_decide(post_t, cur, cost, sims, rng): """One decision of Bayes-adaptive MCTS (root sampling, as in BAMCP). Each scenario draws a market (mu, sigma^2) from the posterior and a 20-day price path from it. Tree nodes are histories of (action, observed move), where the move over each 5-day step is bucketed into down / sideways / up, so later decisions can react to what the simulated market did. Below the root, actions are chosen by UCT; a history seen for the first time is added to the tree and the episode is finished with the default policy (keep the position). At the root, every scenario is played once for each action (common random numbers), which removes most sampling noise from the comparison of root actions. `sims` counts episodes.""" mn, kn, an, bn = post_t n_act, n_scen = len(MC_GRID), sims // len(MC_GRID) sig2 = bn / rng.gamma(an, 1.0, n_scen) mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(n_scen) R = TREE_STEP * mu[:, None] + np.sqrt(TREE_STEP * sig2)[:, None] * \ rng.standard_normal((n_scen, TREE_DEPTH)) thr = 0.5 * math.sqrt(TREE_STEP * bn / max(an - 1.0, 0.5)) bucket = np.where(R < -thr, 0, np.where(R > thr, 2, 1)).tolist() gross = np.expm1(R).tolist() tree, one_g = {}, 1.0 - GAMMA root_tot = [0.0] * n_act su = suu = 0.0 k = 0 for s in range(n_scen): g_s, b_s = gross[s], bucket[s] c = UCT_C * math.sqrt(max(suu / k - (su / k) ** 2, 1e-12)) if k > 10 else 0.1 for a0 in range(n_act): w_prev = MC_GRID[a0] wealth = 1.0 + w_prev * g_s[0] - cost * abs(w_prev - cur) h, path = a0 * 3 + b_s[0] + 1, [] for d in range(1, TREE_DEPTH): node = tree.get(h) if node is None: # expansion, then default policy node = tree[h] = ([0] * n_act, [0.0] * n_act) path.append((node[0], node[1], MC_GRID.index(w_prev))) for dd in range(d, TREE_DEPTH): wealth *= 1.0 + w_prev * g_s[dd] break cnt, tot = node untried = [i for i in range(n_act) if cnt[i] == 0] if untried: # nearest position first a = min(untried, key=lambda i: abs(MC_GRID[i] - w_prev)) else: logn = math.log(sum(cnt)) a, best = 0, -1e300 for i in range(n_act): v = tot[i] / cnt[i] + c * math.sqrt(logn / cnt[i]) if v > best: a, best = i, v w = MC_GRID[a] wealth *= 1.0 + w * g_s[d] - cost * abs(w - w_prev) path.append((cnt, tot, a)) h = h * 16 + a * 3 + b_s[d] + 1 w_prev = w u = (max(wealth, 1e-6) ** one_g - 1.0) / one_g root_tot[a0] += u su += u suu += u * u k += 1 for cnt, tot, a in path: cnt[a] += 1 tot[a] += u return MC_GRID[max(range(n_act), key=root_tot.__getitem__)] def mcts_weights(post, cost, seed, start=0, sims=TREE_SIMS): rng = np.random.default_rng(seed) w, cur = np.zeros(len(post)), 0.0 for t in range(start, len(post)): cur = mcts_decide(post[t], cur, cost, sims, rng) w[t] = cur return w def tree_weights(post, cost, seed, start=0): """Exhaustive search of the same 4-step decision tree by backward induction on a fixed set of sampled scenarios (the limit that MCTS approximates by sampling). State before each decision: current position and the bucketed price history. Every action sequence is evaluated on the same scenarios, so comparisons are paired.""" rng = np.random.default_rng(seed) grid = np.array(MC_GRID) n_act, one_g = len(grid), 1.0 - GAMMA switch = np.abs(grid[None, :] - grid[:, None]) # [from, to] w, cur = np.zeros(len(post)), 0 for t in range(start, len(post)): mn, kn, an, bn = post[t] sig2 = bn / rng.gamma(an, 1.0, MC_PATHS) mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(MC_PATHS) R = TREE_STEP * mu[:, None] + np.sqrt(TREE_STEP * sig2)[:, None] * \ rng.standard_normal((MC_PATHS, TREE_DEPTH)) thr = 0.5 * math.sqrt(TREE_STEP * bn / max(an - 1.0, 0.5)) bucket = np.where(R < -thr, 0, np.where(R > thr, 2, 1)) gross = np.expm1(R) v = np.ones((MC_PATHS, n_act)) # value after the last step for d in range(TREE_DEPTH - 1, -1, -1): # f[n, from, to]: wealth factor of step d, raised to 1 - gamma f = 1.0 + grid[None, None, :] * gross[:, d, None, None] - cost * switch[None] q = np.maximum(f, 1e-6) ** one_g * v[:, None, :] if d == 0: cur = int(np.argmin(q[:, cur, :].mean(axis=0))) # gamma > 1: minimize break code = np.zeros(MC_PATHS, dtype=int) # history of moves before d for j in range(d): code = code * 3 + bucket[:, j] onehot = np.zeros((MC_PATHS, 3 ** d)) onehot[np.arange(MC_PATHS), code] = 1.0 sums = onehot.T @ q.reshape(MC_PATHS, -1) # [group, from * to] best = sums.reshape(-1, n_act, n_act).argmin(axis=2) # [group, from] v = np.take_along_axis(q, best[code][:, :, None], axis=2)[:, :, 0] w[t] = grid[cur] return w def vol_weights(post, target): """Volatility timing without any view on direction: w = min(1, target / sigma_hat).""" return np.minimum(1.0, target / predictive_vol(post)) def match_exposure(post, sl, exposure): """Target volatility for which vol_weights has the given mean exposure on slice sl.""" lo, hi = 1e-5, 1.0 for _ in range(60): mid = 0.5 * (lo + hi) if vol_weights(post, mid)[sl].mean() < exposure: lo = mid else: hi = mid return 0.5 * (lo + hi) # ---------- accounting ---------- def net_returns(w, r_next, cost, rf=0.0): """w[t] earns the simple return of day t+1, the cash part 1 - w[t] earns the risk-free rate rf; cost is paid on changes of position. Returns total returns.""" turn = np.abs(np.diff(np.concatenate([[0.0], w]))) return w * np.expm1(r_next) + (1.0 - w) * rf - cost * turn def sharpe(ret, ppy): s = ret.std() return float(ret.mean() / s * math.sqrt(ppy)) if s > 0 else 0.0 def metrics(ret, w, ppy, rf=0.0): """ret: total returns; the Sharpe ratio is computed on returns in excess of rf.""" eq = np.cumprod(1.0 + ret) years = len(ret) / ppy dd = 1.0 - eq / np.maximum.accumulate(eq) return dict( total=float(eq[-1] - 1.0), cagr=float(eq[-1] ** (1 / years) - 1.0), vol=float(ret.std() * math.sqrt(ppy)), sharpe=sharpe(ret - rf, ppy), maxdd=float(dd.max()), exposure=float(w.mean()), trades_per_year=float((np.abs(np.diff(w)) > 0).sum() / years), ) def window_returns(ret, n): eq = np.concatenate([[1.0], np.cumprod(1.0 + ret)]) return eq[n:] / eq[:-n] - 1.0 # ---------- statistical tests ---------- def shift_test(w, r_next, cost, ppy, window, rng, n_shifts=N_SHIFTS, rf=0.0): """Random-timing benchmark: circularly shift the position series against returns. Keeps exposure, turnover and holding periods; destroys any timing skill.""" n, base = len(w), sharpe(net_returns(w, r_next, cost, rf) - rf, ppy) sh, win = np.empty(n_shifts), np.empty(n_shifts) for i, k in enumerate(rng.integers(window, n - window, n_shifts)): ret = net_returns(np.roll(w, k), r_next, cost, rf) sh[i] = sharpe(ret - rf, ppy) win[i] = (window_returns(ret, window) > 0).mean() return dict(p_value=float((1 + (sh >= base).sum()) / (1 + n_shifts)), shift_sharpe_median=float(np.median(sh)), shift_win_frac_median=float(np.median(win))) def stationary_bootstrap_idx(n, mean_block, rng): new = rng.random(n) < 1.0 / mean_block new[0] = True start_pos = np.maximum.accumulate(np.where(new, np.arange(n), 0)) starts = rng.integers(0, n, n) return (starts[start_pos] + np.arange(n) - start_pos) % n def bootstrap_sharpe_diff(ret_a, ret_b, ppy, rng, n_boot=2000, mean_block=20): """Paired stationary bootstrap of Sharpe(a) - Sharpe(b).""" n, diffs = len(ret_a), np.empty(n_boot) for i in range(n_boot): idx = stationary_bootstrap_idx(n, mean_block, rng) diffs[i] = sharpe(ret_a[idx], ppy) - sharpe(ret_b[idx], ppy) lo, hi = np.percentile(diffs, [2.5, 97.5]) return dict(diff=sharpe(ret_a, ppy) - sharpe(ret_b, ppy), lo=float(lo), hi=float(hi), p_le0=float((diffs <= 0).mean())) def spa_sharpe(ex, bench, ppy, rng, n_boot=2000, mean_block=20): """Hansen's (2005) test for superior predictive ability, applied to Sharpe-ratio differences against a benchmark. ex: [T, K] excess returns of K strategies; bench: [T] excess returns of the benchmark. H0: no strategy has a higher Sharpe ratio than the benchmark. Studentized with bootstrap standard errors; returns the consistent p-value (SPA_c) and White's reality-check p-value (no studentization, least favorable recentering).""" T, K = ex.shape def sr(x): return x.mean(axis=0) / x.std(axis=0) * math.sqrt(ppy) d = sr(ex) - sr(bench[:, None]) boot = np.empty((n_boot, K)) for b in range(n_boot): idx = stationary_bootstrap_idx(T, mean_block, rng) boot[b] = sr(ex[idx]) - sr(bench[idx][:, None]) se = np.maximum(boot.std(axis=0), 1e-12) stat = max(float((d / se).max()), 0.0) keep = d / se >= -math.sqrt(2.0 * math.log(math.log(T))) cen = boot - np.where(keep, d, 0.0) # SPA_c recentering p_spa = float((np.maximum((cen / se).max(axis=1), 0.0) >= stat).mean()) rc_stat = float(d.max()) p_rc = float(((boot - d).max(axis=1) >= rc_stat).mean()) return dict(p_spa=p_spa, p_rc=p_rc, best=int(np.argmax(d)), best_diff=float(d.max()), k=K) def pbo_cscv(ex, n_blocks=16): """Probability of backtest overfitting by combinatorially symmetric cross-validation (Bailey et al. 2017). ex: [T, N] excess returns of N variants. For every split of the n_blocks blocks into two halves, the variant with the best in-sample Sharpe ratio is ranked out of sample; PBO is the share of splits in which it falls in the bottom half.""" from itertools import combinations T, N = ex.shape L = T // n_blocks x = ex[:L * n_blocks].reshape(n_blocks, L, N) s1, s2 = x.sum(axis=1), (x * x).sum(axis=1) # [blocks, N] logits, oos_best = [], [] for c in combinations(range(n_blocks), n_blocks // 2): m = np.zeros(n_blocks, dtype=bool) m[list(c)] = True def sr(mask): n = mask.sum() * L mu = s1[mask].sum(axis=0) / n return mu / np.sqrt(np.maximum(s2[mask].sum(axis=0) / n - mu * mu, 1e-18)) is_, oos = sr(m), sr(~m) best = int(np.argmax(is_)) omega = (stats.rankdata(oos)[best]) / (N + 1) logits.append(math.log(omega / (1 - omega))) logits = np.array(logits) return dict(pbo=float((logits <= 0).mean()), n_splits=len(logits), n_variants=N) def psr(ret, sr_star=0.0): """Probabilistic Sharpe ratio (Bailey and Lopez de Prado); sr_star per period.""" n, sr = len(ret), ret.mean() / ret.std() g3, g4 = stats.skew(ret), stats.kurtosis(ret, fisher=False) den = math.sqrt(max(1.0 - g3 * sr + (g4 - 1.0) / 4.0 * sr * sr, 1e-12)) return float(stats.norm.cdf((sr - sr_star) * math.sqrt(n - 1) / den)) def deflated_sr_threshold(trial_sharpes_per_period): """Expected maximum per-period Sharpe among N unskilled trials.""" n, v = len(trial_sharpes_per_period), np.var(trial_sharpes_per_period, ddof=1) em = 0.5772156649 z = (1 - em) * stats.norm.ppf(1 - 1.0 / n) + em * stats.norm.ppf(1 - 1.0 / (n * math.e)) return float(math.sqrt(v) * z)