def safe_backtest_mean_reversion(df, train_ratio=0.7):
    """
    Safe: Split data into in-sample (optimization) and out-of-sample (testing)
    """
    split_idx = int(len(df) * train_ratio)
# In-sample: optimize parameters
    df_train = df.iloc[:split_idx]
    best_params = optimize_parameters(df_train)
# Out-of-sample: test on fresh data
    df_test = df.iloc[split_idx:]
    metrics_test = backtest_mean_reversion(df_test, best_params)
return metrics_test
NEVER optimize on the same data twice
NEVER use out-of-sample data for parameter selection

def walk_forward_mean_reversion(df, in_sample_size=504, out_sample_size=126):
    """
    Rolling window validation
In-sample: 504 days (2 years) - optimize parameters
    Out-of-sample: 126 days (6 months) - test on fresh data
    """
    results = []
for start_idx in range(0, len(df) - in_sample_size - out_sample_size, 126):
        df_in = df.iloc[start_idx:start_idx + in_sample_size]
        df_out = df.iloc[start_idx + in_sample_size:start_idx + in_sample_size + out_sample_size]
# Train
        best_period, best_zscore = optimize_on_training(df_in)
# Test
        metrics = backtest_mean_reversion(df_out, best_period, best_zscore)
results.append({
            'Period': f"{start_idx} to {start_idx + in_sample_size + out_sample_size}",
            'Best_Period': best_period,
            'Best_ZScore': best_zscore,
            'In_Sample_Sharpe': metrics['in_sharpe'],
            'Out_Sample_Sharpe': metrics['out_sharpe'],
            'Degradation_Pct': (metrics['in_sharpe'] - metrics['out_sharpe']) / metrics['in_sharpe'] * 100,
        })
return pd.DataFrame(results)
Healthy: 15-30% Sharpe degradation
Suspicious: >50% degradation = overfitting

def stress_test_regimes(df):
    """Test mean reversion across different market conditions"""
# Identify regimes
    df['Returns'] = df['Close'].pct_change()
    df['Volatility'] = df['Returns'].rolling(20).std()
    df['Trend'] = df['Close'].rolling(50).apply(lambda x: np.polyfit(range(len(x)), x, 1)[0])
# Classify regimes
    df['Regime'] = 'Normal'
    df.loc[df['Volatility'] > df['Volatility'].quantile(0.75), 'Regime'] = 'High_Vol'
    df.loc[df['Volatility'] < df['Volatility'].quantile(0.25), 'Regime'] = 'Low_Vol'
    df.loc[abs(df['Trend']) > df['Trend'].std(), 'Regime'] = 'Trending'
# Test each regime separately
    results = {}
    for regime in df['Regime'].unique():
        df_regime = df[df['Regime'] == regime]
        metrics = backtest_mean_reversion(df_regime)
        results[regime] = metrics
return results
Mean reversion should work in Normal/Low_Vol
Mean reversion typically FAILS in Trending regimes

def apply_realistic_mean_reversion_costs(df, asset_class='forex'):
    """Apply realistic transaction costs"""
if asset_class == 'forex':
        # Spread: 1-2 pips, Slippage: 1 pip, Commission: 0.5 pip
        # Total: ~2.5 pips on forex = 0.025% * 100 = 0.0025
        transaction_cost = 0.0025
elif asset_class == 'equities':
        # Commission: $0.10 per share, Spread: $0.01
        # On $100 stock: 0.11% = 0.0011
        transaction_cost = 0.0011
elif asset_class == 'crypto':
        # Exchange fee: 0.1%, Slippage: 0.2%
        # Total: 0.3% = 0.003
        transaction_cost = 0.003
# Apply to strategy
    df['Position_Change'] = df['Position'].diff().abs()
    df['Transaction_Impact'] = df['Position_Change'] * transaction_cost
    df['Net_Daily_Return'] = df['Daily_Return'] - df['Transaction_Impact']
    df['Strategy_Return'] = df['Position'].shift(1) * df['Net_Daily_Return']
return df

def reality_check_mean_reversion(metrics):
    """Flag unrealistic backtest results"""
red_flags = []
# Sharpe > 2.0 is unrealistic
    if metrics['Sharpe_Ratio'] > 2.0:
        red_flags.append(f"⚠️ Sharpe {metrics['Sharpe_Ratio']:.2f} > 2.0 (unrealistic)")
# Win rate > 65% is suspicious
    if metrics['Win_Rate'] > 65:
        red_flags.append(f"⚠️ Win rate {metrics['Win_Rate']:.1f}% > 65% (suspicious)")
# Drawdown < -5% (profit only) is unrealistic
    if metrics['Max_Drawdown'] > -5:
        red_flags.append(f"⚠️ Max drawdown {metrics['Max_Drawdown']:.1f}% > -5% (too good)")
# Return should degrade with costs
    if metrics['BH_Return'] > metrics['Total_Return'] * 0.5:
        red_flags.append(f"⚠️ Underperforming buy & hold by >50%")
# Check Sharpe degradation
    if hasattr(metrics, 'sharpe_degradation'):
        if metrics['sharpe_degradation'] > 0.5:
            red_flags.append(f"⚠️ Sharpe degradation {metrics['sharpe_degradation']:.1%} > 50% (overfitting)")
if len(red_flags) == 0:
        print("✓ Backtest passes reality checks")
        return True
    else:
        print("⚠️ WARNING: Suspicious metrics detected")
        for flag in red_flags:
            print(flag)
        return False

class SafeMeanReversionBacktester:
    def __init__(self, symbol, period=20, zscore=2.0):
        self.symbol = symbol
        self.period = period
        self.zscore = zscore
        self.df = None
        self.validation_report = {}
def load_validated_data(self, start_date, end_date, min_days=1000):
        """Load with validation"""
        self.df = yf.download(self.symbol, start=start_date, end=end_date)
if len(self.df) < min_days:
            raise ValueError(f"Need {min_days} days, got {len(self.df)}")
# Check quality
        missing = self.df['Close'].isnull().sum()
        if missing > 0:
            self.df = self.df.dropna()
return self.df
def safe_backtest(self, start_date, end_date):
        """Run safe backtest with validation"""
        self.load_validated_data(start_date, end_date)
# Calculate mean reversion
        self.df['SMA'] = self.df['Close'].rolling(self.period).mean()
        self.df['Std'] = self.df['Close'].rolling(self.period).std()
        self.df['Zscore'] = (self.df['Close'] - self.df['SMA']) / self.df['Std']
# Generate signals (with lag to prevent look-ahead)
        self.df['Zscore_prev'] = self.df['Zscore'].shift(1)
        self.df['Signal'] = 0
        self.df.loc[self.df['Zscore_prev'] < -self.zscore, 'Signal'] = 1
        self.df.loc[self.df['Zscore_prev'] > self.zscore, 'Signal'] = -1
# Position
        self.df['Position'] = self.df['Signal'].fillna(method='ffill').fillna(0)
# Returns with costs
        self.df['Daily_Return'] = self.df['Close'].pct_change()
        self.df['Transaction_Cost'] = self.df['Position'].diff().abs() * 0.001
        self.df['Net_Return'] = self.df['Daily_Return'] - self.df['Transaction_Cost']
        self.df['Strategy_Return'] = self.df['Position'].shift(1) * self.df['Net_Return']
# Cumulative
        self.df['Cumulative_Strategy'] = (1 + self.df['Strategy_Return']).cumprod()
        self.df['Cumulative_BH'] = (1 + self.df['Daily_Return']).cumprod()
# Calculate metrics
        sr = self.df['Strategy_Return'].dropna()
        metrics = {
            'Total_Return': (self.df['Cumulative_Strategy'].iloc[-1] - 1) * 100,
            'BH_Return': (self.df['Cumulative_BH'].iloc[-1] - 1) * 100,
            'Sharpe_Ratio': (sr.mean() / sr.std()) * np.sqrt(252) if sr.std() > 0 else 0,
            'Win_Rate': len(sr[sr > 0]) / len(sr) * 100,
            'Max_Drawdown': ((self.df['Cumulative_Strategy'] / self.df['Cumulative_Strategy'].expanding().max() - 1).min() * 100),
        }
# Reality check
        reality_check_mean_reversion(metrics)
return metrics