backtest-bias 0.1.0__tar.gz

backtest_bias-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ayan Jain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backtest_bias-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: backtest-bias
+Version: 0.1.0
+Summary: Checks whether your backtest data is lying to you: survivorship, dead-name coverage, integrity gates for financial price panels.
+Author: Ayan Jain
+License: MIT
+Project-URL: Homepage, https://github.com/Finance-broski/backtest-bias
+Keywords: backtesting,survivorship-bias,quant,data-quality,point-in-time
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5
+Requires-Dist: numpy>=1.23
+Dynamic: license-file
+
+# backtest-bias
+
+**Checks whether your backtest data is lying to you.**
+
+Most backtests don't fail loudly. They flatter you quietly, because the data underneath them is
+missing the stocks that died. This library tests your price panel for that — in one line — and
+tells you roughly what it costs when it finds it.
+
+## The measured numbers this library is built on
+
+These are not estimates. I measured them on real Indian market data and published the write-ups:
+
+- **23%** of the top-500 Indian stocks (as of 2015) are invisible to yfinance today — delisted,
+  merged, suspended. Any backtest built on it runs on survivors only.
+- Survivor-only universes inflated equal-weight returns by **+0.8 to +2.5 pp/yr** depending on
+  universe vintage — same market, same method, 3x difference. Anyone quoting one number is guessing.
+- On the most widely used Kaggle NSE dataset, index-membership look-ahead added **+10%** terminal
+  wealth cap-weighted and **+43%** equal-weighted over 2010-2021. The bias depends on construction.
+- Comparable mid/large-cap universes lose **10-30%** of their names over multi-year windows.
+  If your panel lost zero, your panel is the problem.
+
+## Install
+
+```
+pip install backtest-bias
+```
+
+## 30 seconds to a verdict
+
+```python
+import pandas as pd
+from backtest_bias import check_survivorship
+
+prices = pd.read_csv("my_panel.csv")   # wide (date x symbols) or long (date/symbol/close)
+report = check_survivorship(prices)
+print(report.summary())
+```
+
+```
+survivorship check: 412 symbols over 9.2y, 0 died in-window (0%)
+verdict: SEVERE - 412 names over 9.2y with zero deaths is the survivor-only signature;
+comparable universes lose 10%-30% of names over such windows
+expect EW returns inflated roughly +0.8-2.5 pp/yr vs an honest universe (measured,
+vintage-dependent; see backtest_bias.REFERENCES)
+```
+
+## What v0.1 ships
+
+| function | what it answers |
+|---|---|
+| `check_survivorship(prices)` | does my universe contain the stocks that died, or only the winners? Full report with severity and a measured bias estimate |
+| `dead_name_ratio(prices)` | one number: what fraction of my names end before the panel does. `0.0` = pure survivor panel |
+| `assert_integrity(prices)` | CI gate: raise if the panel smells survivor-only, so a silent re-download of bad data fails your pipeline instead of flattering your backtest |
+
+Input handling is forgiving: wide panels, long frames, sniffed column names, NaN-padded
+histories. Anything the library cannot judge honestly, it raises instead of guessing.
+
+## Roadmap
+
+- **v0.2** — look-ahead / point-in-time violations: fundamentals dated by period instead of
+  announcement, index membership applied backwards, same-bar signal fills
+- **v0.3** — rename-continuity and corporate-action gap detection
+
+## Who
+
+I'm [Ayan Jain](https://www.linkedin.com/in/ayanjain259). I build point-in-time Indian
+equity data and audit backtests and datasets for bias — the measured numbers above come from
+those audits. If you want this class of check run on your own backtest by a person instead of a
+library, that's my [Bias Check](https://forms.gle/sAvosfHnitCBm9FD7): fixed price, 48h, written
+verdict.
+
+MIT licensed. Issues and war stories welcome — especially datasets that fooled you.

backtest_bias-0.1.0/README.md

@@ -0,0 +1,72 @@
+# backtest-bias
+
+**Checks whether your backtest data is lying to you.**
+
+Most backtests don't fail loudly. They flatter you quietly, because the data underneath them is
+missing the stocks that died. This library tests your price panel for that — in one line — and
+tells you roughly what it costs when it finds it.
+
+## The measured numbers this library is built on
+
+These are not estimates. I measured them on real Indian market data and published the write-ups:
+
+- **23%** of the top-500 Indian stocks (as of 2015) are invisible to yfinance today — delisted,
+  merged, suspended. Any backtest built on it runs on survivors only.
+- Survivor-only universes inflated equal-weight returns by **+0.8 to +2.5 pp/yr** depending on
+  universe vintage — same market, same method, 3x difference. Anyone quoting one number is guessing.
+- On the most widely used Kaggle NSE dataset, index-membership look-ahead added **+10%** terminal
+  wealth cap-weighted and **+43%** equal-weighted over 2010-2021. The bias depends on construction.
+- Comparable mid/large-cap universes lose **10-30%** of their names over multi-year windows.
+  If your panel lost zero, your panel is the problem.
+
+## Install
+
+```
+pip install backtest-bias
+```
+
+## 30 seconds to a verdict
+
+```python
+import pandas as pd
+from backtest_bias import check_survivorship
+
+prices = pd.read_csv("my_panel.csv")   # wide (date x symbols) or long (date/symbol/close)
+report = check_survivorship(prices)
+print(report.summary())
+```
+
+```
+survivorship check: 412 symbols over 9.2y, 0 died in-window (0%)
+verdict: SEVERE - 412 names over 9.2y with zero deaths is the survivor-only signature;
+comparable universes lose 10%-30% of names over such windows
+expect EW returns inflated roughly +0.8-2.5 pp/yr vs an honest universe (measured,
+vintage-dependent; see backtest_bias.REFERENCES)
+```
+
+## What v0.1 ships
+
+| function | what it answers |
+|---|---|
+| `check_survivorship(prices)` | does my universe contain the stocks that died, or only the winners? Full report with severity and a measured bias estimate |
+| `dead_name_ratio(prices)` | one number: what fraction of my names end before the panel does. `0.0` = pure survivor panel |
+| `assert_integrity(prices)` | CI gate: raise if the panel smells survivor-only, so a silent re-download of bad data fails your pipeline instead of flattering your backtest |
+
+Input handling is forgiving: wide panels, long frames, sniffed column names, NaN-padded
+histories. Anything the library cannot judge honestly, it raises instead of guessing.
+
+## Roadmap
+
+- **v0.2** — look-ahead / point-in-time violations: fundamentals dated by period instead of
+  announcement, index membership applied backwards, same-bar signal fills
+- **v0.3** — rename-continuity and corporate-action gap detection
+
+## Who
+
+I'm [Ayan Jain](https://www.linkedin.com/in/ayanjain259). I build point-in-time Indian
+equity data and audit backtests and datasets for bias — the measured numbers above come from
+those audits. If you want this class of check run on your own backtest by a person instead of a
+library, that's my [Bias Check](https://forms.gle/sAvosfHnitCBm9FD7): fixed price, 48h, written
+verdict.
+
+MIT licensed. Issues and war stories welcome — especially datasets that fooled you.

backtest_bias-0.1.0/backtest_bias/__init__.py

@@ -0,0 +1,17 @@
+"""backtest-bias: checks whether your backtest data is lying to you.
+
+v0.1 ships one killer check done properly - survivorship - plus a CI gate.
+Roadmap: look-ahead/PIT violations (v0.2), rename-continuity & corporate-action gaps (v0.3).
+"""
+from .core import (
+    REFERENCES,
+    SurvivorshipReport,
+    assert_integrity,
+    check_survivorship,
+    dead_name_ratio,
+    to_wide,
+)
+
+__version__ = "0.1.0"
+__all__ = ["check_survivorship", "dead_name_ratio", "assert_integrity", "to_wide",
+           "SurvivorshipReport", "REFERENCES", "__version__"]

backtest_bias-0.1.0/backtest_bias/core.py

@@ -0,0 +1,157 @@
+"""backtest-bias core: survivorship checks for financial price panels.
+
+Design rules:
+- The library checks YOUR data. It ships no market data of its own.
+- The packaged benchmarks are published, measured numbers (sources in REFERENCES) so a finding
+  can be quantified, not just flagged.
+- Anything the library cannot judge honestly, it says so instead of guessing.
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+
+import numpy as np
+import pandas as pd
+
+# Published, measured benchmarks that motivated this library (see README for the write-ups).
+# These quantify what a survivor-only panel typically does to a backtest.
+REFERENCES = {
+    "IN": {
+        "death_rate_range": (0.10, 0.30),   # fraction of a mid/large-cap universe that stops
+                                            # trading over a multi-year window (measured 2013 &
+                                            # 2015 vintages, Indian top-500)
+        "bias_pp_per_year": (0.8, 2.5),     # measured EW return inflation from survivor-only
+                                            # universes, vintage-dependent
+        "construction_dependence": "+10% terminal wealth (cap-weighted) to +43% (equal-weight) "
+                                   "measured on one widely used dataset, 2010-2021",
+    },
+}
+
+
+def to_wide(prices: pd.DataFrame,
+            date_col: str = None, symbol_col: str = None, value_col: str = None) -> pd.DataFrame:
+    """Accept a wide panel (DatetimeIndex x symbols) or a long frame (date/symbol/price columns)
+    and return wide. Column names are sniffed case-insensitively when not given."""
+    if isinstance(prices.index, pd.DatetimeIndex) and prices.shape[1] > 1 and \
+            not any(str(c).lower() in ("symbol", "ticker") for c in prices.columns):
+        return prices.sort_index()
+    df = prices.copy()
+    cols = {str(c).lower(): c for c in df.columns}
+    date_col = date_col or next((cols[k] for k in ("date", "dt", "day", "time") if k in cols), None)
+    symbol_col = symbol_col or next((cols[k] for k in ("symbol", "ticker", "scrip", "name") if k in cols), None)
+    value_col = value_col or next((cols[k] for k in ("close", "adj_close", "price", "px", "nav") if k in cols), None)
+    if not (date_col and symbol_col and value_col):
+        raise ValueError("could not sniff long-format columns; pass date_col/symbol_col/value_col")
+    df[date_col] = pd.to_datetime(df[date_col])
+    return df.pivot_table(index=date_col, columns=symbol_col, values=value_col, aggfunc="last").sort_index()
+
+
+def dead_name_ratio(prices: pd.DataFrame, gap_days: int = 45, min_obs: int = 60,
+                    as_of=None, **to_wide_kw) -> float:
+    """Fraction of symbols whose data ENDS well before the panel does (i.e. names that died and
+    were kept — the thing survivor-only panels don't have). 0.0 = your panel only contains
+    the living."""
+    w = to_wide(prices, **to_wide_kw)
+    end = pd.Timestamp(as_of) if as_of is not None else w.index.max()
+    counted = dead = 0
+    for c in w.columns:
+        s = w[c].dropna()
+        if len(s) < min_obs:
+            continue
+        counted += 1
+        if s.index.max() < end - pd.Timedelta(days=gap_days):
+            dead += 1
+    if counted == 0:
+        raise ValueError(f"no symbol has >= {min_obs} observations; nothing to judge")
+    return dead / counted
+
+
+@dataclass
+class SurvivorshipReport:
+    n_symbols: int
+    n_dead_in_window: int
+    dead_ratio: float
+    window_years: float
+    survivor_only_suspected: bool
+    severity: str                      # "clean" | "warn" | "severe"
+    detail: str
+    market: str = "IN"
+    dead_symbols: list = field(default_factory=list)
+
+    def estimated_bias_pp_per_year(self):
+        """Published measured band for what a survivor-only panel adds to EW returns."""
+        ref = REFERENCES.get(self.market)
+        return ref["bias_pp_per_year"] if (ref and self.survivor_only_suspected) else (0.0, 0.0)
+
+    def summary(self) -> str:
+        lines = [f"survivorship check: {self.n_symbols} symbols over {self.window_years:.1f}y, "
+                 f"{self.n_dead_in_window} died in-window ({self.dead_ratio:.0%})",
+                 f"verdict: {self.severity.upper()} - {self.detail}"]
+        lo, hi = self.estimated_bias_pp_per_year()
+        if hi > 0:
+            lines.append(f"expect EW returns inflated roughly +{lo}-{hi} pp/yr vs an honest "
+                         f"universe (measured, vintage-dependent; see backtest_bias.REFERENCES)")
+        return "\n".join(lines)
+
+    def __repr__(self):
+        return f"<SurvivorshipReport {self.severity}: {self.n_dead_in_window}/{self.n_symbols} dead, {self.window_years:.1f}y>"
+
+
+def check_survivorship(prices: pd.DataFrame, gap_days: int = 45, min_obs: int = 60,
+                       min_names: int = 20, min_years: float = 3.0, market: str = "IN",
+                       **to_wide_kw) -> SurvivorshipReport:
+    """THE core question: does your universe contain names that died inside your test window?
+
+    A multi-year panel of 20+ names with ZERO deaths carries the survivor-only signature:
+    every stock in it is a stock that made it to the end, and your backtest literally cannot
+    buy the ones that didn't. Reference universes lose 10-30% of names over such windows."""
+    w = to_wide(prices, **to_wide_kw)
+    end = w.index.max()
+    years = max((end - w.index.min()).days / 365.25, 0.01)
+    firsts, lasts, dead = {}, {}, []
+    for c in w.columns:
+        s = w[c].dropna()
+        if len(s) < min_obs:
+            continue
+        firsts[c], lasts[c] = s.index.min(), s.index.max()
+        if lasts[c] < end - pd.Timedelta(days=gap_days):
+            dead.append(c)
+    n = len(firsts)
+    if n == 0:
+        raise ValueError(f"no symbol has >= {min_obs} observations; nothing to judge")
+    ratio = len(dead) / n
+
+    if ratio == 0 and n >= min_names and years >= min_years:
+        sev, suspect = "severe", True
+        detail = (f"{n} names over {years:.1f}y with zero deaths is the survivor-only signature; "
+                  f"comparable universes lose "
+                  f"{REFERENCES[market]['death_rate_range'][0]:.0%}-{REFERENCES[market]['death_rate_range'][1]:.0%} "
+                  f"of names over such windows" if market in REFERENCES else
+                  f"{n} names over {years:.1f}y with zero deaths is the survivor-only signature")
+    elif ratio == 0 and n >= min_names:
+        sev, suspect = "warn", False
+        detail = f"zero deaths but only {years:.1f}y of window - re-run on your full research span"
+    elif ratio < 0.05 and years >= 5:
+        sev, suspect = "warn", False
+        detail = f"suspiciously few deaths ({ratio:.1%}) for a {years:.1f}y window - check how the universe was built"
+    else:
+        sev, suspect = "clean", False
+        detail = "dead names present in the panel; survivor-only construction not indicated"
+
+    return SurvivorshipReport(n_symbols=n, n_dead_in_window=len(dead), dead_ratio=ratio,
+                              window_years=years, survivor_only_suspected=suspect,
+                              severity=sev, detail=detail, market=market,
+                              dead_symbols=sorted(dead)[:50])
+
+
+def assert_integrity(prices: pd.DataFrame, min_dead_ratio: float = 0.05,
+                     gap_days: int = 45, min_obs: int = 60, **to_wide_kw) -> None:
+    """CI gate: raise if the panel smells survivor-only. Wire it into your data pipeline so a
+    silent re-download of survivor-only data fails the build instead of flattering the backtest."""
+    r = dead_name_ratio(prices, gap_days=gap_days, min_obs=min_obs, **to_wide_kw)
+    if r < min_dead_ratio:
+        raise AssertionError(
+            f"survivorship gate failed: dead-name ratio {r:.1%} < required {min_dead_ratio:.0%}. "
+            f"This panel likely only contains stocks that survived to the end; backtests on it "
+            f"will overstate returns (measured +0.8-2.5 pp/yr EW on Indian data).")

backtest_bias-0.1.0/backtest_bias.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: backtest-bias
+Version: 0.1.0
+Summary: Checks whether your backtest data is lying to you: survivorship, dead-name coverage, integrity gates for financial price panels.
+Author: Ayan Jain
+License: MIT
+Project-URL: Homepage, https://github.com/Finance-broski/backtest-bias
+Keywords: backtesting,survivorship-bias,quant,data-quality,point-in-time
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5
+Requires-Dist: numpy>=1.23
+Dynamic: license-file
+
+# backtest-bias
+
+**Checks whether your backtest data is lying to you.**
+
+Most backtests don't fail loudly. They flatter you quietly, because the data underneath them is
+missing the stocks that died. This library tests your price panel for that — in one line — and
+tells you roughly what it costs when it finds it.
+
+## The measured numbers this library is built on
+
+These are not estimates. I measured them on real Indian market data and published the write-ups:
+
+- **23%** of the top-500 Indian stocks (as of 2015) are invisible to yfinance today — delisted,
+  merged, suspended. Any backtest built on it runs on survivors only.
+- Survivor-only universes inflated equal-weight returns by **+0.8 to +2.5 pp/yr** depending on
+  universe vintage — same market, same method, 3x difference. Anyone quoting one number is guessing.
+- On the most widely used Kaggle NSE dataset, index-membership look-ahead added **+10%** terminal
+  wealth cap-weighted and **+43%** equal-weighted over 2010-2021. The bias depends on construction.
+- Comparable mid/large-cap universes lose **10-30%** of their names over multi-year windows.
+  If your panel lost zero, your panel is the problem.
+
+## Install
+
+```
+pip install backtest-bias
+```
+
+## 30 seconds to a verdict
+
+```python
+import pandas as pd
+from backtest_bias import check_survivorship
+
+prices = pd.read_csv("my_panel.csv")   # wide (date x symbols) or long (date/symbol/close)
+report = check_survivorship(prices)
+print(report.summary())
+```
+
+```
+survivorship check: 412 symbols over 9.2y, 0 died in-window (0%)
+verdict: SEVERE - 412 names over 9.2y with zero deaths is the survivor-only signature;
+comparable universes lose 10%-30% of names over such windows
+expect EW returns inflated roughly +0.8-2.5 pp/yr vs an honest universe (measured,
+vintage-dependent; see backtest_bias.REFERENCES)
+```
+
+## What v0.1 ships
+
+| function | what it answers |
+|---|---|
+| `check_survivorship(prices)` | does my universe contain the stocks that died, or only the winners? Full report with severity and a measured bias estimate |
+| `dead_name_ratio(prices)` | one number: what fraction of my names end before the panel does. `0.0` = pure survivor panel |
+| `assert_integrity(prices)` | CI gate: raise if the panel smells survivor-only, so a silent re-download of bad data fails your pipeline instead of flattering your backtest |
+
+Input handling is forgiving: wide panels, long frames, sniffed column names, NaN-padded
+histories. Anything the library cannot judge honestly, it raises instead of guessing.
+
+## Roadmap
+
+- **v0.2** — look-ahead / point-in-time violations: fundamentals dated by period instead of
+  announcement, index membership applied backwards, same-bar signal fills
+- **v0.3** — rename-continuity and corporate-action gap detection
+
+## Who
+
+I'm [Ayan Jain](https://www.linkedin.com/in/ayanjain259). I build point-in-time Indian
+equity data and audit backtests and datasets for bias — the measured numbers above come from
+those audits. If you want this class of check run on your own backtest by a person instead of a
+library, that's my [Bias Check](https://forms.gle/sAvosfHnitCBm9FD7): fixed price, 48h, written
+verdict.
+
+MIT licensed. Issues and war stories welcome — especially datasets that fooled you.

backtest_bias-0.1.0/backtest_bias.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+backtest_bias/__init__.py
+backtest_bias/core.py
+backtest_bias.egg-info/PKG-INFO
+backtest_bias.egg-info/SOURCES.txt
+backtest_bias.egg-info/dependency_links.txt
+backtest_bias.egg-info/requires.txt
+backtest_bias.egg-info/top_level.txt
+tests/test_core.py

backtest_bias-0.1.0/backtest_bias.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

backtest_bias-0.1.0/backtest_bias.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas>=1.5
+numpy>=1.23

backtest_bias-0.1.0/backtest_bias.egg-info/top_level.txt

@@ -0,0 +1 @@
+backtest_bias

backtest_bias-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "backtest-bias"
+version = "0.1.0"
+description = "Checks whether your backtest data is lying to you: survivorship, dead-name coverage, integrity gates for financial price panels."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Ayan Jain" }]
+requires-python = ">=3.9"
+dependencies = ["pandas>=1.5", "numpy>=1.23"]
+keywords = ["backtesting", "survivorship-bias", "quant", "data-quality", "point-in-time"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+
+[project.urls]
+Homepage = "https://github.com/Finance-broski/backtest-bias"
+
+[tool.setuptools.packages.find]
+include = ["backtest_bias*"]

backtest_bias-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

backtest_bias-0.1.0/tests/test_core.py

@@ -0,0 +1,88 @@
+"""backtest-bias v0.1 regression: synthetic panels with known truth; every verdict must match.
+Run: python -m pytest tests/ -q   (or python tests/test_core.py)"""
+import sys, os
+import numpy as np
+import pandas as pd
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from backtest_bias import (assert_integrity, check_survivorship, dead_name_ratio, to_wide)
+
+RNG = np.random.default_rng(7)
+DAYS = pd.bdate_range("2015-01-01", "2024-12-31")
+
+
+def _walk(n):
+    return 100 * np.exp(np.cumsum(RNG.normal(0.0003, 0.02, n)))
+
+
+def survivor_panel(n_names=30):
+    """Everyone lives to the end: the survivor-only signature."""
+    return pd.DataFrame({f"S{i:03d}": _walk(len(DAYS)) for i in range(n_names)}, index=DAYS)
+
+
+def honest_panel(n_names=30, death_frac=0.3):
+    """30% of names die somewhere in the middle: what real history looks like."""
+    df = survivor_panel(n_names)
+    dead = list(df.columns[: int(n_names * death_frac)])
+    for i, c in enumerate(dead):
+        cut = DAYS[len(DAYS) // 3 + i * 40]
+        df.loc[df.index > cut, c] = np.nan
+    return df, dead
+
+
+def test_survivor_only_flagged_severe():
+    rep = check_survivorship(survivor_panel())
+    assert rep.severity == "severe" and rep.survivor_only_suspected
+    assert rep.n_dead_in_window == 0
+    lo, hi = rep.estimated_bias_pp_per_year()
+    assert hi == 2.5 and lo == 0.8
+    assert "survivor-only signature" in rep.summary()
+
+
+def test_honest_panel_clean():
+    df, dead = honest_panel()
+    rep = check_survivorship(df)
+    assert rep.severity == "clean" and not rep.survivor_only_suspected
+    assert rep.n_dead_in_window == len(dead)
+    assert set(rep.dead_symbols) == set(dead)
+    assert rep.estimated_bias_pp_per_year() == (0.0, 0.0)
+
+
+def test_dead_name_ratio_numbers():
+    df, dead = honest_panel(30, 0.3)
+    r = dead_name_ratio(df)
+    assert abs(r - len(dead) / 30) < 1e-9
+    assert dead_name_ratio(survivor_panel()) == 0.0
+
+
+def test_assert_integrity_gate():
+    with pytest.raises(AssertionError, match="survivorship gate failed"):
+        assert_integrity(survivor_panel())
+    df, _ = honest_panel()
+    assert_integrity(df)  # should not raise
+
+
+def test_long_format_sniffing():
+    df, dead = honest_panel(25)
+    long = df.stack().rename("close").reset_index()
+    long.columns = ["Date", "Ticker", "Close"]
+    rep = check_survivorship(long)
+    assert rep.n_symbols == 25 and rep.n_dead_in_window == len(dead)
+    w = to_wide(long)
+    assert w.shape[1] == 25 and isinstance(w.index, pd.DatetimeIndex)
+
+
+def test_short_window_only_warns():
+    short = survivor_panel().iloc[:300]
+    rep = check_survivorship(short)
+    assert rep.severity == "warn" and not rep.survivor_only_suspected
+
+
+if __name__ == "__main__":
+    for fn in [test_survivor_only_flagged_severe, test_honest_panel_clean,
+               test_dead_name_ratio_numbers, test_assert_integrity_gate,
+               test_long_format_sniffing, test_short_window_only_warns]:
+        fn()
+        print(f"  PASS {fn.__name__}")
+    print("backtest-bias v0.1: GREEN")