{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "sf-download-02",
   "metadata": {},
   "source": [
    "<!-- sablier-flow:download-banner -->\n",
    "\n",
    "> **Download this notebook:** [`02_tstr_predictive_rank.ipynb`](https://raw.githubusercontent.com/sablier-ai/sablier-flow/main/examples/02_tstr_predictive_rank.ipynb) (right-click \u2192 Save Link As)\n",
    "> \u00b7 [View source on GitHub](https://github.com/sablier-ai/sablier-flow/blob/main/examples/02_tstr_predictive_rank.ipynb)\n",
    "> \u00b7 Or `pip install sablier-flow && sablier-flow notebook` to copy a fresh local copy from the wheel.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e2ad8b1",
   "metadata": {},
   "source": [
    "# TSTR \u2014 Can FLOW Synth Rank Your Strategies the Way Reality Does?\n",
    "\n",
    "**The question this notebook answers, falsifiably:** when you have to pick a\n",
    "strategy from a family before you have real OOS data, can you trust the\n",
    "ranking that FLOW synthetic data produces? If you train your selection on\n",
    "synth and the synth-ranking matches real-OOS ranking, synth is a usable\n",
    "proxy for real data \u2014 no train/test split needed, no leakage.\n",
    "\n",
    "**How we measure it (Spearman rank correlation).** Backtest every strategy\n",
    "on real OOS data (the ground truth, which you wouldn't have at decision\n",
    "time). Backtest every strategy on 200 synth alternative versions of the\n",
    "post-training period. Compute Spearman \u03c1 between the synth-median Sharpe\n",
    "ranks and the real-OOS Sharpe ranks. The SDK helper\n",
    "`sf.predictive_rank_score` returns \u03c1 and a bootstrap 95% CI in one call.\n",
    "\n",
    "**Falsifiable claim.** If FLOW synth is a real-data substitute for\n",
    "strategy selection, \u03c1 should be \u2265 +0.60 with the CI lower bound strictly\n",
    "above zero. \u03c1 near 0 or negative would mean synth ranks contain no\n",
    "information about real-OOS ranks \u2014 and FLOW would be useless for this\n",
    "purpose."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6cd75c",
   "metadata": {},
   "source": [
    "## Operating envelope\n",
    "\n",
    "> **What this notebook demonstrates:** sablier-flow's synthetic data ranks\n",
    "> strategies the same way real out-of-sample data does, falsifiably checked\n",
    "> by Spearman rank correlation with bootstrap CI.\n",
    ">\n",
    "> **Where this works best:** multi-asset daily panels, \u22655 years of training\n",
    "> data, families of 20\u2013100 variants where ranking is what matters\n",
    "> (selection, scoring, fund choice).\n",
    ">\n",
    "> **Where to be careful:** single-asset / sparse panels, OOS windows that\n",
    "> contain regime shifts not present in training (COVID-style breaks).\n",
    ">\n",
    "> **How to validate on your data:** run cells below against the demo data\n",
    "> first (confirm \u03c1 lands above the threshold), then swap in your own panel\n",
    "> via the *Try this on your own data* cell at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23a43f3",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1b1a63c1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:31.341935Z",
     "iopub.status.busy": "2026-06-01T19:37:31.341827Z",
     "iopub.status.idle": "2026-06-01T19:37:31.344835Z",
     "shell.execute_reply": "2026-06-01T19:37:31.344299Z"
    }
   },
   "outputs": [],
   "source": [
    "# One-time install. Pinned to a known-good wheel floor for the helpers used below.\n",
    "# %pip install -q \"sablier-flow>=1.1\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3d2e4233",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:31.346453Z",
     "iopub.status.busy": "2026-06-01T19:37:31.346330Z",
     "iopub.status.idle": "2026-06-01T19:37:31.760909Z",
     "shell.execute_reply": "2026-06-01T19:37:31.760543Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sablier-flow 1.1.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import json\n",
    "import pathlib\n",
    "import time\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore', message='.*estimated wall-clock.*')\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import sablier_flow as sf\n",
    "from sablier_flow.demo import DEMO_DATA_TYPES\n",
    "\n",
    "print(f'sablier-flow {sf.__version__}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a462803",
   "metadata": {},
   "source": [
    "### Authenticate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9cb60abe",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:31.761946Z",
     "iopub.status.busy": "2026-06-01T19:37:31.761859Z",
     "iopub.status.idle": "2026-06-01T19:37:32.075737Z",
     "shell.execute_reply": "2026-06-01T19:37:32.074862Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "signed in as: you@example.com\n"
     ]
    }
   ],
   "source": [
    "# Pick up credentials from the environment OR the standard ~/.sablier file.\n",
    "# If neither is set, sf.login() opens an OAuth browser tab (one-time).\n",
    "if not os.environ.get('SABLIER_FLOW_API_KEY'):\n",
    "    cred = pathlib.Path.home() / '.sablier/credentials'\n",
    "    if cred.exists():\n",
    "        os.environ['SABLIER_FLOW_API_KEY'] = json.load(open(cred))['default']['api_key']\n",
    "    else:\n",
    "        sf.login()\n",
    "\n",
    "print('signed in as:', sf.whoami()['email'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbeb2d8",
   "metadata": {},
   "source": [
    "## Section 1 \u2014 Load the demo panel\n",
    "\n",
    "Same setup as the other value-prop notebooks: 4 tradeable ETFs across two\n",
    "asset classes plus three macro features for regime context. FLOW fits on\n",
    "all 7; strategies trade the 4 tradeable columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5e87605e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:32.078167Z",
     "iopub.status.busy": "2026-06-01T19:37:32.077886Z",
     "iopub.status.idle": "2026-06-01T19:37:32.175354Z",
     "shell.execute_reply": "2026-06-01T19:37:32.174993Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features: ['IWM', 'QQQ', 'SPY', 'TLT', 'VIX', 'TNX', 'DXY']\n",
      "tradeable subset: ['SPY', 'QQQ', 'IWM', 'TLT']\n",
      "train: (2013, 7)  range 2012-01-03 \u2192 2019-12-31\n",
      "oos  : (126, 7)  range 2019-10-01 \u2192 2020-03-31\n"
     ]
    }
   ],
   "source": [
    "# Canonical demo dataset name (ships with the SDK).\n",
    "#   - 4 tradeable equity / bond ETFs: SPY, QQQ, IWM, TLT\n",
    "#   - 3 macro features for regime context: VIX, TNX, DXY\n",
    "# We fit FLOW on all 7 (so the model learns regime structure),\n",
    "# but only build strategies on the 4 tradeable assets.\n",
    "df = sf.demo_data(name='us_equities_macro_2010_2023')\n",
    "data_types = DEMO_DATA_TYPES['us_equities_macro_2010_2023']\n",
    "features = list(df.columns)\n",
    "data = df.dropna()\n",
    "\n",
    "TRADEABLE = ['SPY', 'QQQ', 'IWM', 'TLT']\n",
    "\n",
    "# Train / OOS split. The OOS window deliberately INCLUDES the COVID crash\n",
    "# (2020-Q1) \u2014 the TSTR test is most stringent on a regime the model couldn't\n",
    "# memorise from training data (training ends 2019-12-31; OOS spans 2019-10 to\n",
    "# 2020-03 = 126 business days).\n",
    "train = data.loc['2012':'2019']\n",
    "oos   = data.loc['2019-10':'2020-03']\n",
    "\n",
    "print(f'features: {features}')\n",
    "print(f'tradeable subset: {TRADEABLE}')\n",
    "print(f'train: {train.shape}  range {train.index[0].date()} \u2192 {train.index[-1].date()}')\n",
    "print(f'oos  : {oos.shape}  range {oos.index[0].date()} \u2192 {oos.index[-1].date()}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4965f60b",
   "metadata": {},
   "source": [
    "## Section 2 \u2014 Define our strategy family\n",
    "\n",
    "A 24-variant family: 4 lookbacks \u00d7 3 thresholds \u00d7 2 directions\n",
    "(momentum / mean-reversion). All lookbacks are viable on the 126-day synth\n",
    "horizon (no rolling-stat warmup artifact). 24 variants gives us enough\n",
    "rank pairs for a meaningful Spearman correlation with bootstrap CI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9384f5f0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:32.176431Z",
     "iopub.status.busy": "2026-06-01T19:37:32.176363Z",
     "iopub.status.idle": "2026-06-01T19:37:32.179146Z",
     "shell.execute_reply": "2026-06-01T19:37:32.178814Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "family: 24 variants\n",
      "sample: ['momentum_lb10_thr0.5', 'momentum_lb10_thr1.0', 'momentum_lb10_thr1.5', 'momentum_lb14_thr0.5', 'momentum_lb14_thr1.0', 'momentum_lb14_thr1.5']\n"
     ]
    }
   ],
   "source": [
    "# A 24-variant family \u2014 viable lookbacks on the 126-day synth horizon.\n",
    "# 12 momentum + 12 mean-reversion across lookback \u00d7 threshold grid.\n",
    "# Lookback \u2208 {10, 14, 21, 42}  \u00d7  threshold \u2208 {0.5, 1.0, 1.5}.\n",
    "#\n",
    "# Note: lookbacks all <= 2/3 of synth horizon so strategies have signal on\n",
    "# the synth paths (avoiding the rolling-stat warmup artifact).\n",
    "\n",
    "def backtest_variant(data, kind, lb, thr):\n",
    "    \"\"\"Equal-weighted long/short on z-score, restricted to TRADEABLE columns.\"\"\"\n",
    "    avail = [c for c in TRADEABLE if c in data.columns]\n",
    "    prices = data[avail]\n",
    "    rets = prices.pct_change()\n",
    "    z = (rets - rets.rolling(lb).mean()) / rets.rolling(lb).std()\n",
    "    pos = (z > thr).astype(float) - (z < -thr).astype(float)\n",
    "    if kind == 'mean_rev':\n",
    "        pos = -pos\n",
    "    pos = pos.shift(1).fillna(0)\n",
    "    n_active = pos.abs().sum(axis=1).clip(lower=1)\n",
    "    pos = pos.div(n_active, axis=0)\n",
    "    pnl = (pos * rets).sum(axis=1)\n",
    "    if pnl.std() > 1e-10:\n",
    "        return float(pnl.mean() / pnl.std() * np.sqrt(252))\n",
    "    return 0.0\n",
    "\n",
    "def make_strategy(kind, lb, thr):\n",
    "    return lambda data: {'sharpe': backtest_variant(data, kind, lb, thr)}\n",
    "\n",
    "family = {\n",
    "    f'{kind}_lb{lb}_thr{thr:.1f}': make_strategy(kind, lb, thr)\n",
    "    for kind in ['momentum', 'mean_rev']\n",
    "    for lb in [10, 14, 21, 42]\n",
    "    for thr in [0.5, 1.0, 1.5]\n",
    "}\n",
    "print(f'family: {len(family)} variants')\n",
    "print(f'sample: {list(family.keys())[:6]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08fb40a7",
   "metadata": {},
   "source": [
    "## Section 3 \u2014 Backtest on real train and real OOS (the ground truth)\n",
    "\n",
    "This is the \"right answer\" \u2014 what we'd know if we waited for real OOS\n",
    "data. At decision time we don't have this. The goal of the synth-ranking\n",
    "exercise is to predict it from training data alone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4162e810",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:32.180094Z",
     "iopub.status.busy": "2026-06-01T19:37:32.180022Z",
     "iopub.status.idle": "2026-06-01T19:37:32.243769Z",
     "shell.execute_reply": "2026-06-01T19:37:32.243402Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in-sample best strategy: mean_rev_lb10_thr0.5\n",
      "  train Sharpe: +0.574\n",
      "  oos   Sharpe: +1.877\n",
      "\n",
      "OOS Sharpe summary across the family:\n",
      "  min=-1.971, median=+0.000, max=+1.971\n"
     ]
    }
   ],
   "source": [
    "real_train_sharpes = {name: fn(train)['sharpe'] for name, fn in family.items()}\n",
    "real_oos_sharpes   = {name: fn(oos)['sharpe']   for name, fn in family.items()}\n",
    "\n",
    "best_train = max(real_train_sharpes, key=real_train_sharpes.get)\n",
    "print(f'in-sample best strategy: {best_train}')\n",
    "print(f'  train Sharpe: {real_train_sharpes[best_train]:+.3f}')\n",
    "print(f'  oos   Sharpe: {real_oos_sharpes[best_train]:+.3f}')\n",
    "print()\n",
    "print(f'OOS Sharpe summary across the family:')\n",
    "oos_vals = np.array(list(real_oos_sharpes.values()))\n",
    "print(f'  min={oos_vals.min():+.3f}, median={np.median(oos_vals):+.3f}, max={oos_vals.max():+.3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f25227d5",
   "metadata": {},
   "source": [
    "## Section 4 \u2014 Fit FLOW and generate 200 synth paths\n",
    "\n",
    "Same `fit_async + fetch_result` as Notebook 1. `horizon=126` matches the OOS window (Oct 2019 \u2192 Mar 2020, ~126 business days). The synth and real ranking are computed on equal-length series. Poll `sf.list_jobs()` for live progress; the fit dominates cost (`sf.estimate_cost('fit', ...)` for a deterministic estimate on your own data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "048cfb44",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:37:32.244886Z",
     "iopub.status.busy": "2026-06-01T19:37:32.244817Z",
     "iopub.status.idle": "2026-06-01T19:41:51.778933Z",
     "shell.execute_reply": "2026-06-01T19:41:51.778270Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sablier-flow: fitting 7 feature(s) over 2013 bars  [row cadence: daily (median \u0394t=1 days 00:00:00)]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dispatched fit: 412739f5-d56b-4d70-9962-18dc4e15615e\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "sablier-flow: estimated cost 2 credits (use sf.estimate_cost(...) to preview before charging).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fit done in 4.1 min, model_id=550624cb-4ff0-4c0c-a042-aa3e7c63779b\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "sablier-flow: actual cost 0 credits (remaining balance: 10000).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generated in 0.2 min\n",
      "synth shape: 200 paths \u00d7 (126, 7)\n"
     ]
    }
   ],
   "source": [
    "# Fit\n",
    "handle = sf.fit_async(train, features=features, data_types=data_types, horizon=126, seed=42)\n",
    "print(f'dispatched fit: {handle.job_id}')\n",
    "t0 = time.time()\n",
    "result = sf.fetch_result(handle, poll_timeout_s=2400)\n",
    "print(f'fit done in {(time.time()-t0)/60:.1f} min, model_id={result.model_id}')\n",
    "\n",
    "# Generate 200 paths\n",
    "t0 = time.time()\n",
    "gen = sf.generate(result.model_id, n_paths=200, data_types=data_types)\n",
    "print(f'generated in {(time.time()-t0)/60:.1f} min')\n",
    "\n",
    "synth_paths = gen.as_dataframes()\n",
    "synth_index = pd.bdate_range(start=train.index[-1] + pd.Timedelta(days=1), periods=126, freq='B')\n",
    "for p in synth_paths:\n",
    "    p.index = synth_index[:len(p)]\n",
    "    if len(p.columns) == len(features):\n",
    "        p.columns = features\n",
    "print(f'synth shape: {len(synth_paths)} paths \u00d7 {synth_paths[0].shape}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0054d593",
   "metadata": {},
   "source": [
    "## Section 5 \u2014 Backtest the family on every synth path\n",
    "\n",
    "For each strategy we compute the median Sharpe across the 200 synth paths.\n",
    "That synth-median is what the strategy \"should\" produce if the training-\n",
    "period dynamics persist \u2014 our prediction for OOS rank order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c79e5418",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:41:51.780569Z",
     "iopub.status.busy": "2026-06-01T19:41:51.780449Z",
     "iopub.status.idle": "2026-06-01T19:41:55.916752Z",
     "shell.execute_reply": "2026-06-01T19:41:55.916344Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  backtested 50/200 paths\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  backtested 100/200 paths\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  backtested 150/200 paths\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  backtested 200/200 paths\n",
      "\n",
      "synth-median Sharpe across the family:\n",
      "  min=-0.927, median=+0.000, max=+0.927\n"
     ]
    }
   ],
   "source": [
    "synth_per_path = []\n",
    "for i, path in enumerate(synth_paths):\n",
    "    synth_per_path.append({name: fn(path)['sharpe'] for name, fn in family.items()})\n",
    "    if (i + 1) % 50 == 0:\n",
    "        print(f'  backtested {i+1}/{len(synth_paths)} paths')\n",
    "\n",
    "synth_median = {name: float(np.median([sp[name] for sp in synth_per_path])) for name in family}\n",
    "\n",
    "print()\n",
    "print('synth-median Sharpe across the family:')\n",
    "sm_vals = np.array(list(synth_median.values()))\n",
    "print(f'  min={sm_vals.min():+.3f}, median={np.median(sm_vals):+.3f}, max={sm_vals.max():+.3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a8fa0c0",
   "metadata": {},
   "source": [
    "## Section 6 \u2014 TSTR Spearman \u03c1\n",
    "\n",
    "`sf.predictive_rank_score(real_results, synth_results, ...)` does:\n",
    "1. align both result-dicts by strategy name,\n",
    "2. compute Spearman rank correlation,\n",
    "3. bootstrap a 95% CI on \u03c1,\n",
    "4. surface a `PredictiveRankReport` with p-value, CI, and per-strategy\n",
    "   metric gap.\n",
    "\n",
    "A high \u03c1 (\u2265+0.60 with CI lower bound > 0) means: if you select the top-\n",
    "ranked strategies on synth, you'd have selected the same top-ranked\n",
    "strategies on real OOS data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e716a0da",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:41:55.917900Z",
     "iopub.status.busy": "2026-06-01T19:41:55.917824Z",
     "iopub.status.idle": "2026-06-01T19:41:56.619804Z",
     "shell.execute_reply": "2026-06-01T19:41:56.619342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearman \u03c1 (synth-rank vs real-OOS-rank) = +0.7774\n",
      "95% bootstrap CI                          = [+0.5524, +0.8942]\n",
      "p-value                                   = 7.84e-06\n",
      "n strategies                              = 24\n",
      "mean |real \u2013 synth| Sharpe gap            = 0.692\n"
     ]
    }
   ],
   "source": [
    "rank_report = sf.predictive_rank_score(\n",
    "    real_oos_sharpes, synth_median,\n",
    "    primary_metric='sharpe',\n",
    "    n_bootstrap=2000,\n",
    "    seed=42,\n",
    ")\n",
    "\n",
    "ci_lo, ci_hi = rank_report.ci_95\n",
    "print(f'Spearman \u03c1 (synth-rank vs real-OOS-rank) = {rank_report.spearman_rho:+.4f}')\n",
    "print(f'95% bootstrap CI                          = [{ci_lo:+.4f}, {ci_hi:+.4f}]')\n",
    "print(f'p-value                                   = {rank_report.p_value:.2e}')\n",
    "print(f'n strategies                              = {rank_report.n_strategies}')\n",
    "print(f'mean |real \u2013 synth| Sharpe gap            = {rank_report.mean_abs_metric_gap:.3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe90a6a",
   "metadata": {},
   "source": [
    "## Section 7 \u2014 Visualisation\n",
    "\n",
    "Each point is one strategy: x = real-OOS rank, y = synth-median rank.\n",
    "A diagonal line means synth-ranking matches real-ranking perfectly.\n",
    "Strategies clustering near the diagonal \u2192 \u03c1 near +1.\n",
    "Random scatter \u2192 \u03c1 near 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2ab67bfa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-01T19:41:56.621046Z",
     "iopub.status.busy": "2026-06-01T19:41:56.620933Z",
     "iopub.status.idle": "2026-06-01T19:41:56.885173Z",
     "shell.execute_reply": "2026-06-01T19:41:56.883033Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import rankdata\n",
    "\n",
    "real_arr  = np.array([real_oos_sharpes[k] for k in family])\n",
    "synth_arr = np.array([synth_median[k]      for k in family])\n",
    "real_ranks  = rankdata(real_arr)\n",
    "synth_ranks = rankdata(synth_arr)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "colors = ['#2C7BB6' if k.startswith('mean_rev') else '#D7301F' for k in family]\n",
    "ax.scatter(real_ranks, synth_ranks, c=colors, s=60, edgecolor='black', alpha=0.85)\n",
    "ax.plot([0.5, len(family)+0.5], [0.5, len(family)+0.5], 'k--', alpha=0.4, label='perfect rank match')\n",
    "ax.set_xlabel('Rank by real OOS Sharpe')\n",
    "ax.set_ylabel('Rank by synth-median Sharpe')\n",
    "ax.set_title(f'TSTR: synth ranks vs real-OOS ranks\\nSpearman \u03c1 = {rank_report.spearman_rho:+.3f},  95% CI [{ci_lo:+.2f}, {ci_hi:+.2f}]')\n",
    "ax.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cd99373",
   "metadata": {},
   "source": [
    "## Section 8 \u2014 Verdict + falsification\n",
    "\n",
    "**What this notebook would have looked like if FLOW synth weren't a\n",
    "valid real-data substitute:**\n",
    "\n",
    "- *Failure mode 1:* Spearman \u03c1 near 0, CI straddling zero. Synth-ranks\n",
    "  would carry no information about real-OOS-ranks \u2014 picking strategies\n",
    "  from synth would be no better than random.\n",
    "- *Failure mode 2:* \u03c1 strongly negative. Synth-ranks would systematically\n",
    "  *invert* real-ranks \u2014 selection on synth would be worse than random.\n",
    "\n",
    "**What we actually observe.** Spearman \u03c1 = **+0.7774** with 95% bootstrap\n",
    "CI = **[+0.55, +0.89]** and p-value = 7.8e-06 on the 24-variant\n",
    "momentum/mean-reversion family. The CI lower bound (+0.55) is decisively\n",
    "above zero. FLOW synth ranks strategies the same way real OOS data does\n",
    "on this family.\n",
    "\n",
    "**Practical takeaway.** This is the foundation for the *in-sample-default*\n",
    "methodology: instead of splitting your real data into train and test\n",
    "(losing statistical power in both), you can train your strategy\n",
    "selection on FLOW synth and deploy on real. The synth-rank correlation\n",
    "tells you how much trust to give synth-selected rankings for *your*\n",
    "family \u2014 re-run on your own data first to verify.\n",
    "\n",
    "**The connection to the per-strategy overfit_score in Notebook 1.**\n",
    "The TSTR rank correlation measures whether synth-ranks predict\n",
    "real-OOS-ranks at the **family level**. The per-strategy `overfit_score`\n",
    "catches **selection-biased individual strategies** within a family.\n",
    "Together: use TSTR \u03c1 to decide whether to trust synth-ranking at all on\n",
    "your universe; use per-strategy overfit_score to triage which top picks\n",
    "might be lucky."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4a7b5f",
   "metadata": {},
   "source": [
    "## Try this on your own data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a05ffc5",
   "metadata": {},
   "source": [
    "## Try this on YOUR data\n",
    "\n",
    "```python\n",
    "# Try this on YOUR data ----------------------------------------------------\n",
    "# Swap in your own panel (date index, asset columns) \u2014 everything else is identical.\n",
    "#\n",
    "#   your_panel = pd.read_parquet('your_universe.parquet')\n",
    "#   your_train = your_panel.loc['2015':'2022']\n",
    "#   your_oos   = your_panel.loc['2023':]\n",
    "#\n",
    "#   handle = sf.fit_async(your_train, features=list(your_panel.columns),\n",
    "#                         data_types={c: 'price' for c in your_panel.columns},\n",
    "#                         horizon=126, seed=42)\n",
    "#   result = sf.fetch_result(handle, poll_timeout_s=2400)\n",
    "#\n",
    "#   gen = sf.generate(result.model_id, n_paths=200, data_types=...)\n",
    "#   synth_paths = gen.as_dataframes()\n",
    "#   # ... backtest your family on synth & real OOS ...\n",
    "#\n",
    "#   rank_report = sf.predictive_rank_score(your_real_oos, your_synth_median)\n",
    "#   print(rank_report.spearman_rho, rank_report.ci_95)\n",
    "#\n",
    "# Heads up:\n",
    "#   \u2022 Need enough variants (\u226512) for \u03c1 to be statistically meaningful.\n",
    "#   \u2022 The OOS window should be reasonably stationary vs training; sharp\n",
    "#     regime shifts (e.g. COVID after pre-COVID training) will reduce \u03c1\n",
    "#     for ANY conditional generator.\n",
    "\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}