Expected value per trade = (0.70 × 1.5) + (0.30 × -1.0) = 1.05 - 0.30 = 0.75
This means +0.75 units per trade on average.
With 100 trades: expected profit = 75 units

f* = (p × b - q) / b
With p = 0.70, b = 1.5:
f* = (0.70 × 1.5 - 0.30) / 1.5
f* = (1.05 - 0.30) / 1.5
f* = 0.75 / 1.5
f* = 0.50 = 50% Kelly

import numpy as np
import pandas as pd
from scipy.stats import binom_test
def validate_high_win_rate(trades, min_win_rate=0.65, min_samples=50):
    """
    Statistical test: Is observed win rate significantly different from 50%?
    Uses binomial test to confirm edge isn't due to luck.
    """
    returns = np.array([t['return'] for t in trades])
    wins = (returns > 0).sum()
    total_trades = len(trades)
if total_trades < min_samples:
        raise ValueError(f"Only {total_trades} trades; need {min_samples}")
# Observed win rate
    observed_wr = wins / total_trades
if observed_wr < min_win_rate:
        raise ValueError(f"Win rate {observed_wr:.1%} below threshold {min_win_rate:.1%}")
# Binomial test: p-value that win rate > 50% by chance
    p_value = binom_test(wins, total_trades, 0.5, alternative='greater')
return {
        'observed_win_rate': observed_wr,
        'expected_random_wr': 0.5,
        'trades_needed_for_edge': _calculate_min_trades_for_edge(observed_wr),
        'confidence_level': 1 - p_value,
        'significant_edge': p_value < 0.05
    }
def _calculate_min_trades_for_edge(win_rate, confidence=0.95):
    """How many trades needed to confirm this win rate isn't random?"""
    from scipy.stats import norm
# Z-score for confidence level
    z = norm.ppf((1 + confidence) / 2)
# Minimum sample size
    p = win_rate
    n = (z / (2  (p - 0.5))) * 2
return int(np.ceil(n))
Example validation
trades = [{'return': 0.015}, {'return': -0.008}, {'return': 0.022}, ...] * 50
validation = validate_high_win_rate(trades, min_win_rate=0.65)
print(f"Win rate: {validation['observed_win_rate']:.1%}")
print(f"Significant edge: {validation['significant_edge']}")
print(f"Trades needed for edge: {validation['trades_needed_for_edge']}")

def aggressive_kelly_position_sizing(
    account_size,
    win_rate,
    profit_factor,
    entry_price,
    stop_loss_price,
    kelly_fraction=0.25,
    max_risk_pct=0.05
):
    """
    For high win rate strategies (65%+), use Kelly Criterion more aggressively
    """
    p = win_rate
    q = 1 - win_rate
    b = profit_factor
# Full Kelly
    kelly_full = (p * b - q) / b
# Aggressive fraction (25% of full Kelly) for high-confidence strategies
    kelly_safe = min(kelly_full * kelly_fraction, max_risk_pct)
# Additional size boost if win rate very high
    if win_rate >= 0.75:
        kelly_safe *= 1.5  # 50% size increase for 75%+ win rate
    elif win_rate >= 0.70:
        kelly_safe *= 1.25  # 25% size increase for 70%+ win rate
risk_amount = account_size * kelly_safe
# Calculate position from risk
    stop_distance = abs(entry_price - stop_loss_price)
    position_size = risk_amount / stop_distance
return {
        'kelly_fraction': kelly_full,
        'adjusted_risk': kelly_safe,
        'position_size': position_size,
        'position_value': position_size * entry_price
    }
Example: 72% win rate, 1.8 profit factor
sizing = aggressive_kelly_position_sizing(
    account_size=100000,
    win_rate=0.72,
    profit_factor=1.8,
    entry_price=150,
    stop_loss_price=147,
    kelly_fraction=0.25
)
print(f"Kelly fraction: {sizing['kelly_fraction']:.2%}")
print(f"Adjusted risk (25% Kelly + boost): {sizing['adjusted_risk']:.2%}")
print(f"Position size: {sizing['position_size']:.0f} shares")

class CompoundGrowthPositionSizer:
    """Maximize long-term capital growth for winning strategies"""
def __init__(
        self,
        historical_win_rate,
        historical_profit_factor,
        account_size=100000,
        growth_target=0.25  # 25% annual growth
    ):
        self.win_rate = historical_win_rate
        self.profit_factor = historical_profit_factor
        self.account_size = account_size
        self.growth_target = growth_target
# Optimal Kelly
        p = historical_win_rate
        q = 1 - p
        self.optimal_kelly = (p * historical_profit_factor - q) / historical_profit_factor
def calculate_position_size_for_growth(self, entry_price, stop_loss_price):
        """
        Size to match growth target
        If strategy expected return is 15% annually with 50 trades,
        and we want 25% growth, scale accordingly
        """
        stop_distance = abs(entry_price - stop_loss_price)
# Expected annual return from strategy
        # (win_rate  profit_factor - loss_rate)  avg_trade_size * num_trades_per_year
        expected_return_per_trade = (self.win_rate * self.profit_factor - (1 - self.win_rate))
if expected_return_per_trade <= 0:
            raise ValueError("Strategy has negative expected return")
# Trades needed per year to hit growth target
        expected_trades_per_year = 50  # Assumption
# Size needed to hit growth target
        # growth_target = expected_return_per_trade  position_size  expected_trades
        required_position_size = (self.growth_target /
                                 (expected_return_per_trade * expected_trades_per_year))
# Cap at Kelly fraction
        kelly_position = (self.account_size  self.optimal_kelly  0.25) / stop_distance
# Use lower of required vs Kelly
        final_size = min(required_position_size, kelly_position)
return {
            'required_size': required_position_size,
            'kelly_capped_size': kelly_position,
            'final_size': final_size,
            'implied_annual_growth': expected_return_per_trade  final_size  expected_trades_per_year
        }

class HighWinRateBacktest:
    """Specialized backtester optimized for high-probability strategies"""
def __init__(
        self,
        prices,
        signals,
        initial_capital=100000,
        position_sizer=None
    ):
        self.prices = prices
        self.signals = signals
        self.capital = initial_capital
        self.position_sizer = position_sizer
        self.trades = []
        self.equity_curve = [initial_capital]
def run(self):
        """Execute backtest with dynamic position sizing"""
        position = None
for i in range(1, len(self.signals)):
            signal = self.signals[i]
            price = self.prices[i]
# Exit on signal reversal
            if position and signal != position['signal']:
                pnl = self._close_position(position, price)
                self.capital += pnl
                self.equity_curve.append(self.capital)
                position = None
# Enter on new signal
            if signal != 0 and not position:
                stop_loss = price  0.98 if signal == 1 else price  1.02
# Dynamic sizing based on strategy performance
                position_size = self.position_sizer.calculate_position_size(
                    account_size=self.capital,
                    entry_price=price,
                    stop_loss_price=stop_loss,
                    trade_history=self.trades
                )
position = {
                    'entry': price,
                    'stop': stop_loss,
                    'size': position_size,
                    'signal': signal,
                    'index': i
                }
if position:
            pnl = self._close_position(position, self.prices[-1])
            self.capital += pnl
return self.equity_curve, self.trades
def _close_position(self, position, exit_price):
        """Calculate PnL and record trade"""
        entry_val = position['entry'] * position['size']
if position['signal'] == 1:
            pnl = (exit_price - position['entry']) * position['size']
        else:
            pnl = (position['entry'] - exit_price) * position['size']
self.trades.append({
            'entry': position['entry'],
            'exit': exit_price,
            'size': position['size'],
            'pnl': pnl,
            'return': pnl / self.capital,
            'bars_held': len(self.prices) - position['index']
        })
return pnl
def analytics(self):
        """Comprehensive performance analysis"""
        if not self.trades:
            return {}
returns = np.array([t['return'] for t in self.trades])
        pnl_values = np.array([t['pnl'] for t in self.trades])
# Win rate metrics
        wins = (pnl_values > 0).sum()
        win_rate = wins / len(self.trades)
        profit_factor = np.sum(pnl_values[pnl_values > 0]) / abs(np.sum(pnl_values[pnl_values < 0]))
# Growth metrics
        total_return = (self.capital - 100000) / 100000
        cagr = total_return ** (252 / len(self.trades)) - 1
        sharpe = np.mean(returns) / np.std(returns) * np.sqrt(252)
# Drawdown
        cumulative = np.cumprod(1 + returns)
        running_max = np.maximum.accumulate(cumulative)
        max_dd = np.min((cumulative - running_max) / running_max)
return {
            'total_return': total_return,
            'cagr': cagr,
            'sharpe_ratio': sharpe,
            'win_rate': win_rate,
            'profit_factor': profit_factor,
            'max_drawdown': max_dd,
            'num_trades': len(self.trades),
            'avg_bars_held': np.mean([t['bars_held'] for t in self.trades])
        }