import numpy as np
import pandas as pd
from scipy.stats import norm, skew, kurtosis
def deflated_sharpe_ratio(
    observed_sharpe: float,
    n_trials: int,
    n_observations: int,
    skewness: float = 0.0,
    excess_kurtosis: float = 0.0,
    sharpe_std: float = None,
) -> dict:
    """
    Compute the Deflated Sharpe Ratio (DSR).
Reference: Bailey & Lopez de Prado (2014)
Args:
        observed_sharpe: best Sharpe ratio from backtests
        n_trials: total number of strategy variations tested
        n_observations: number of return observations
        skewness: skewness of returns
        excess_kurtosis: excess kurtosis of returns
        sharpe_std: standard deviation of Sharpe across trials
Returns:
        Dictionary with DSR statistics
    """
    if sharpe_std is None:
        # Estimate std of Sharpe ratio
        sharpe_std = np.sqrt(
            (1 - skewness * observed_sharpe
             + (excess_kurtosis / 4)  observed_sharpe*2)
            / (n_observations - 1)
        )
# Expected max Sharpe under null (all strategies have zero true Sharpe)
    # E[max] of N draws from N(0, sigma) = sigma * Z_expected_max
    euler_mascheroni = 0.5772156649
    expected_max_sharpe = sharpe_std * (
        (1 - euler_mascheroni) * norm.ppf(1 - 1/n_trials)
        + euler_mascheroni  norm.ppf(1 - 1/(n_trials  np.e))
    )
# DSR: probability that observed Sharpe exceeds expected max
    dsr = norm.cdf(
        (observed_sharpe - expected_max_sharpe)
        / sharpe_std
    )
return {
        "observed_sharpe": observed_sharpe,
        "expected_max_sharpe": expected_max_sharpe,
        "deflated_sharpe_ratio": dsr,
        "n_trials": n_trials,
        "sharpe_std": sharpe_std,
        "significant": dsr > 0.95,  # 95% confidence
        "interpretation": (
            "Likely genuine alpha" if dsr > 0.95
            else "Likely overfit" if dsr < 0.50
            else "Inconclusive"
        ),
    }
Example: tested 100 parameter combinations, best Sharpe = 2.1
result = deflated_sharpe_ratio(
    observed_sharpe=2.1,
    n_trials=100,
    n_observations=252 * 5,
    skewness=-0.5,
    excess_kurtosis=3.0,
)
print(f"DSR: {result['deflated_sharpe_ratio']:.3f}")
print(f"Expected max under null: {result['expected_max_sharpe']:.3f}")
print(f"Interpretation: {result['interpretation']}")

def minimum_backtest_length(
    target_sharpe: float,
    n_trials: int = 1,
    skewness: float = 0.0,
    excess_kurtosis: float = 0.0,
    confidence: float = 0.95,
) -> int:
    """
    Compute minimum backtest length (in observations) for a given
    Sharpe ratio to be statistically significant.
Reference: Bailey & Lopez de Prado (2012)
    """
    z_alpha = norm.ppf(confidence)
# Account for non-normality
    adjustment = 1 - skewness  target_sharpe + (excess_kurtosis / 4)  target_sharpe**2
# Minimum track record length
    min_length = int(np.ceil(
        adjustment  (z_alpha / target_sharpe) * 2
    ))
# Adjust for multiple testing
    if n_trials > 1:
        z_adjusted = norm.ppf(1 - (1 - confidence) / n_trials)  # Bonferroni
        min_length = int(np.ceil(
            adjustment  (z_adjusted / target_sharpe) * 2
        ))
print(f"Minimum backtest length for Sharpe={target_sharpe:.1f}:")
    print(f"  Single test: {min_length} observations")
    print(f"  With {n_trials} trials (Bonferroni): {min_length} observations")
    print(f"  Approximately {min_length / 252:.1f} years of daily data")
return min_length
How long do you need to validate a Sharpe 1.5 strategy?
minimum_backtest_length(target_sharpe=1.5, n_trials=50)

def parameter_stability_analysis(
    X: pd.DataFrame,
    y: pd.Series,
    param_name: str,
    param_values: list,
    model_factory,
    returns: pd.Series,
) -> pd.DataFrame:
    """
    Test how sensitive strategy performance is to parameter changes.
    Stable parameters suggest genuine signal; fragile ones suggest overfitting.
    """
    from sklearn.model_selection import TimeSeriesSplit
results = []
    tscv = TimeSeriesSplit(n_splits=3)
for param_val in param_values:
        fold_sharpes = []
for train_idx, test_idx in tscv.split(X):
            model = model_factory(**{param_name: param_val})
            model.fit(X.iloc[train_idx], y.iloc[train_idx])
            y_pred = model.predict(X.iloc[test_idx])
test_ret = returns.iloc[test_idx]
            strategy_ret = np.where(y_pred == 1, test_ret, 0)
if np.std(strategy_ret) > 0:
                sharpe = np.mean(strategy_ret) / np.std(strategy_ret) * np.sqrt(252)
            else:
                sharpe = 0
fold_sharpes.append(sharpe)
results.append({
            "param_value": param_val,
            "mean_sharpe": np.mean(fold_sharpes),
            "std_sharpe": np.std(fold_sharpes),
            "min_sharpe": min(fold_sharpes),
            "max_sharpe": max(fold_sharpes),
        })
results_df = pd.DataFrame(results)
# Stability metric: coefficient of variation across parameter values
    sharpe_cv = results_df["mean_sharpe"].std() / abs(results_df["mean_sharpe"].mean()) if abs(results_df["mean_sharpe"].mean()) > 0 else np.inf
print(f"\nParameter Stability Analysis: {param_name}")
    print(f"  Sharpe CV across params: {sharpe_cv:.3f}")
    print(f"  Stable: {'Yes' if sharpe_cv < 0.5 else 'No'}")
for _, row in results_df.iterrows():
        print(f"  {param_name}={row['param_value']}: Sharpe={row['mean_sharpe']:.3f} +/- {row['std_sharpe']:.3f}")
return results_df

def whites_reality_check(
    strategy_returns: pd.Series,
    benchmark_returns: pd.Series,
    n_bootstrap: int = 1000,
    block_size: int = 21,
) -> dict:
    """
    White's Reality Check: test if best strategy outperforms
    benchmark after accounting for data snooping.
Uses stationary bootstrap for time series dependence.
    """
    excess_returns = strategy_returns - benchmark_returns
    T = len(excess_returns)
    observed_stat = excess_returns.mean()
# Stationary bootstrap
    bootstrap_stats = []
    for _ in range(n_bootstrap):
        # Generate bootstrap sample with block structure
        sample = np.zeros(T)
        i = 0
        while i < T:
            # Random starting point
            start = np.random.randint(0, T)
            # Geometric block length
            length = np.random.geometric(1 / block_size)
            for j in range(length):
                if i >= T:
                    break
                sample[i] = excess_returns.iloc[(start + j) % T]
                i += 1
# Center the bootstrap (null: no excess return)
        sample = sample - excess_returns.mean()
        bootstrap_stats.append(np.mean(sample))
bootstrap_stats = np.array(bootstrap_stats)
    p_value = np.mean(bootstrap_stats >= observed_stat)
return {
        "observed_mean_excess": observed_stat,
        "p_value": p_value,
        "significant": p_value < 0.05,
        "bootstrap_mean": np.mean(bootstrap_stats),
        "bootstrap_std": np.std(bootstrap_stats),
    }

def walk_forward_overfit_test(
    in_sample_sharpe: float,
    out_of_sample_sharpe: float,
    n_is_observations: int,
    n_oos_observations: int,
) -> dict:
    """
    Test for overfitting by comparing IS and OOS Sharpe ratios.
    """
    # Sharpe ratio degradation
    if in_sample_sharpe != 0:
        degradation = 1 - out_of_sample_sharpe / in_sample_sharpe
    else:
        degradation = 0
# Expected IS Sharpe inflation due to optimization
    # Rule of thumb: IS Sharpe should be within 2x of OOS Sharpe
    overfit_ratio = in_sample_sharpe / max(out_of_sample_sharpe, 0.01)
# Statistical test: are IS and OOS Sharpes significantly different?
    is_se = 1 / np.sqrt(n_is_observations)
    oos_se = 1 / np.sqrt(n_oos_observations)
    z_stat = (in_sample_sharpe - out_of_sample_sharpe) / np.sqrt(is_se2 + oos_se2)
    p_value = 2 * (1 - norm.cdf(abs(z_stat)))
result = {
        "in_sample_sharpe": in_sample_sharpe,
        "out_of_sample_sharpe": out_of_sample_sharpe,
        "degradation": degradation,
        "overfit_ratio": overfit_ratio,
        "z_statistic": z_stat,
        "p_value": p_value,
    }
# Classification
    if degradation < 0.2 and out_of_sample_sharpe > 0.5:
        result["assessment"] = "Likely robust"
    elif degradation < 0.5 and out_of_sample_sharpe > 0:
        result["assessment"] = "Moderate overfitting, potentially salvageable"
    elif out_of_sample_sharpe <= 0:
        result["assessment"] = "Severely overfit, no live edge"
    else:
        result["assessment"] = "Significant overfitting"
print(f"Overfitting Assessment:")
    print(f"  IS Sharpe: {in_sample_sharpe:.2f}")
    print(f"  OOS Sharpe: {out_of_sample_sharpe:.2f}")
    print(f"  Degradation: {degradation:.1%}")
    print(f"  Assessment: {result['assessment']}")
return result

def overfitting_checklist(
    strategy_name: str,
    n_parameters: int,
    n_observations: int,
    in_sample_sharpe: float,
    out_of_sample_sharpe: float,
    n_trials: int,
    turnover: float,
    transaction_costs_bps: float,
) -> dict:
    """
    Comprehensive overfitting risk assessment.
    """
    checks = {}
# 1. Parameter count check
    obs_per_param = n_observations / max(n_parameters, 1)
    checks["params_ok"] = obs_per_param > 100
    checks["obs_per_param"] = obs_per_param
# 2. Deflated Sharpe
    dsr = deflated_sharpe_ratio(in_sample_sharpe, n_trials, n_observations)
    checks["dsr_ok"] = dsr["significant"]
    checks["dsr_value"] = dsr["deflated_sharpe_ratio"]
# 3. IS/OOS degradation
    degradation = 1 - out_of_sample_sharpe / max(in_sample_sharpe, 0.01)
    checks["degradation_ok"] = degradation < 0.4
    checks["degradation"] = degradation
# 4. Cost sensitivity
    gross_sharpe = in_sample_sharpe
    net_sharpe = gross_sharpe - turnover  transaction_costs_bps / 10000  np.sqrt(252)
    checks["survives_costs"] = net_sharpe > 0.5
    checks["net_sharpe"] = net_sharpe
# 5. Overall assessment
    n_passed = sum([
        checks["params_ok"],
        checks["dsr_ok"],
        checks["degradation_ok"],
        checks["survives_costs"],
    ])
checks["overall"] = (
        "DEPLOY" if n_passed == 4
        else "REVIEW" if n_passed >= 3
        else "REJECT"
    )
print(f"\nOverfitting Risk Assessment: {strategy_name}")
    print(f"  Observations/parameter: {obs_per_param:.0f} {'PASS' if checks['params_ok'] else 'FAIL'}")
    print(f"  Deflated Sharpe: {checks['dsr_value']:.3f} {'PASS' if checks['dsr_ok'] else 'FAIL'}")
    print(f"  IS/OOS Degradation: {degradation:.1%} {'PASS' if checks['degradation_ok'] else 'FAIL'}")
    print(f"  Survives costs: Net Sharpe={net_sharpe:.2f} {'PASS' if checks['survives_costs'] else 'FAIL'}")
    print(f"  OVERALL: {checks['overall']}")
return checks