The Kelly Criterion in Trading: Optimal Position Sizing for Sustainable Growth

The gambler who knows when to stop usually knows when to stop winning.

Claude Shannon said that. He applied it to blackjack and beat casinos across Las Vegas in the 1950s—not by counting cards alone, but by precisely controlling his bet size based on the edge he calculated at any given moment. The mathematics behind Shannon's method was first published by John L. Kelly Jr. in 1956 in a paper titled "A New Interpretation of Information Rate." What Shannon understood intuitively, Kelly formalized into an equation.

That equation answers the question every quant trader eventually faces: given an edge, how much capital should I risk on the next trade?

This article dissects the Kelly Criterion from first principles, derives its formula, examines its practical variants, and provides production-grade Python code for real-world position sizing. We will work through the exact scenario from your topic specification—a strategy with a 60% win rate and a 2:1 reward-to-risk ratio—and calculate the optimal fraction.

---

1. The Intuition Behind Kelly

Before the formula, the logic.

Suppose you have a strategy that wins 60% of the time. For every $1 you risk on a winning trade, you gain $2. For every $1 you risk on a losing trade, you lose $1. Simple enough. The edge is real:

• Expected value per trade = (0.60 × $2) − (0.40 × $1) = $1.20 − $0.40 = $0.80 per dollar risked.

But here is the trap: a naive trader might conclude "my edge is 80 cents per dollar, so I'll bet everything." That is precisely the path to ruin. The reason is variance. Even with a 60% edge, consecutive losses occur. A sequence of five losses in a row when betting 100% of capital wipes out the account entirely, eliminating the ability to capture the future edge that those losses were simply deferring.

The Kelly Criterion finds the fraction f of your bankroll to bet such that the logarithm of your wealth grows maximally over time. Why log? Because log returns are additive across time periods, and maximizing expected log wealth is equivalent to maximizing the expected growth rate of the bankroll. It is not about maximizing the expected dollar return—it is about maximizing the rate at which the bankroll compounds.

In Shannon's words from his 1966 lecture at Bell Labs: "My wife and I do not feel that gambling is a legitimate form of recreation. What we are doing is investment." The distinction matters. Kelly is not a betting system. It is a capital growth optimizer.

---

2. Deriving the Kelly Formula

2.1 The Binary Outcome Case

Start with the simplest case: a trade with only two outcomes. You either win (with probability p) or lose (with probability q = 1 − p). When you win, your wealth multiplies by a factor of (1 + b), where b is the net odds received per unit bet. When you lose, you lose your bet, so your wealth multiplies by (1 − f), where f is the fraction of your bankroll bet.

After n trades, your wealth W is:

W(n) = W₀ × (1 + bf)^N_wins × (1 − f)^N_losses

where W₀ is your starting bankroll. Taking logarithms and dividing by n trades gives the average growth rate per trade:

G(f) = (1/n) × ln(W(n)/W₀)
     = p × ln(1 + bf) + q × ln(1 − f)

Kelly asks: what value of f maximizes G(f)? Take the derivative, set it to zero:

dG/df = p × b/(1 + bf) − q/(1 − f) = 0

Solving for f:

p × b/(1 + bf) = q/(1 − f)
p × b × (1 − f) = q × (1 + bf)
pb − pbf = q + qbf
pb − q = bf + qbf
pb − q = f(b + q)

Substituting q = 1 − p:

f = (pb − q) / b
  = (pb − (1 − p)) / b
  = (pb + p − 1) / b
  = p(b + 1) − 1
  = p(b + 1) − 1

Wait—this is not quite right. Let me redo this carefully.

Starting from:

p × b/(1 + bf) = q/(1 − f)

Cross-multiply:

p × b × (1 − f) = q × (1 + bf)
pb − pbf = q + qbf

Collect terms in f:

pb − q = pbf + qbf
pb − q = f(bp + qb? No.)

Let me restart. Move all terms with f to one side:

pb − q = pbf + qbf
pb − q = f(pb + qb? No.)

Actually:

pb − q = bf(p + q)
pb − q = bf × 1
f = (pb − q) / b

Since q = 1 − p:

f = (pb − (1 − p)) / b
  = (pb − 1 + p) / b
  = (p(b + 1) − 1) / b

And since b + 1 = 1 + b is the gross odds received per unit bet (the total return on a win):

f = (p(b + 1) − 1) / b

This is the standard form. For the binary case with win probability p, net odds b, and loss probability q = 1 − p:

f* = (bp − q) / b

or equivalently:

f* = p − q/b

2.2 The Kelly Formula — Standard Form

The most common presentation of the Kelly Criterion is:

f* = (W × p − L) / (W × L)

Where:

• f* = the optimal fraction of bankroll to bet (e.g., 0.25 = bet 25%)
• W = net odds received on a win (for a 2:1 reward-to-risk ratio, W = 2)
• p = probability of a win
• L = amount lost on a loss (normalized to 1; for 1:1 loss, L = 1)

Substituting b = W and q = 1 − p:

f* = (bp − q) / b

For the example from your topic:

• Win rate p = 0.60
• Reward-to-risk ratio = 2:1, so b = 2, q = 0.40

f* = (2 × 0.60 − 0.40) / 2
    = (1.20 − 0.40) / 2
    = 0.80 / 2
    = 0.40

The Kelly Criterion recommends betting 40% of the bankroll per trade.

This result is striking. Most risk management guidelines suggest 1–2% per trade. Kelly is telling you that with a 60% win rate and 2:1 R:R, you can safely bet 40%. But there is a catch: this is the full Kelly, and it assumes the trade outcomes are independent and the parameters are exact. In practice, parameter estimation error and market non-stationarity mean full Kelly is aggressive.

---

3. Why Log Returns? The Geometric Growth Argument

The choice of the logarithm is not arbitrary. It is the solution to a specific problem: maximizing the expected value of the geometric growth rate of wealth over time.

Consider two strategies over 10 trades, each starting with $10,000:

Strategy	Bet fraction	Win sequence (W=win, L=loss)	Final wealth
A	100%	W, L, W, W, L, W, W, L, W, W	$5,120
B	40%	W, L, W, W, L, W, W, L, W, W	$22,031

Strategy B, betting the Kelly fraction, grows wealth. Strategy A, betting 100%, shrinks it—even though Strategy A had a 60% win rate. The reason is the asymmetry between gains and losses. To recover from a 50% loss, you need a 100% gain. Kelly's log utility penalizes catastrophic losses more heavily than equivalent gains reward, which forces conservative betting that protects the compounding base.

The expected geometric growth rate under Kelly is:

G(f*) = p × ln(1 + bf*) + q × ln(1 − f*)

With f* = 0.40, b = 2, p = 0.60, q = 0.40:

G(f*) = 0.60 × ln(1 + 2×0.40) + 0.40 × ln(1 − 0.40)
      = 0.60 × ln(1.80) + 0.40 × ln(0.60)
      = 0.60 × 0.5878 + 0.40 × (−0.5108)
      = 0.3527 − 0.2043
      = 0.1484

This means the bankroll is expected to grow at approximately 14.84% per trade, geometrically. Over 100 trades, this compounds to a growth factor of e^(0.1484 × 100) = e^14.84 ≈ 2,780× the original bankroll. That is the power of geometric compounding under Kelly.

---

4. Fractional Kelly: The Practical Standard

Full Kelly is a mathematical ideal, not a trading prescription. In practice, the finance industry almost universally uses fractional Kelly: betting some fraction k of the Kelly-optimal size, where 0 < k < 1.

The most common values are:

• Half-Kelly (k = 0.5): The standard practical recommendation. Cuts variance by 75% while retaining 75% of the geometric growth rate.
• Quarter-Kelly (k = 0.25): Used when parameter estimates are uncertain or the strategy has known drawdown concerns.
• Single Kelly (k = 1.0): Only appropriate when win rate and R:R are measured over a large sample and the strategy has demonstrated stationarity.

4.1 The Variance Tax

The problem with full Kelly is variance. The standard deviation of returns scales with f, but the expected return scales with ln(1 + bf), which is concave. At high f values, the variance growth outpaces the return growth. Half-Kelly achieves approximately 75% of the growth rate of full Kelly while reducing variance by 75%.

Growth rate ratio (Half-Kelly vs Full-Kelly):
G(0.5f*) / G(f*) ≈ 0.75 (approximately, across typical p and b values)

Variance reduction:
Var(0.5f*) / Var(f*) = 0.25 (a 75% reduction)

This trade-off is compelling: surrendering 25% of the growth rate for a 75% reduction in volatility is almost always the right choice for any strategy with parameter estimation uncertainty—which is to say, all strategies.

4.2 Applying Fractional Kelly to the Example

Returning to our 60% win rate, 2:1 R:R example:

Fraction	Kelly fraction	Position size	Expected growth rate	Variance
Full Kelly	0.40	40% of bankroll	14.84% per trade	High
Half-Kelly	0.20	20% of bankroll	~11.1% per trade	Moderate
Quarter-Kelly	0.10	10% of bankroll	~7.4% per trade	Low

A retail trader deploying this strategy should likely target Half-Kelly (20% of bankroll per trade) as a starting point, with the option to scale up if the strategy demonstrates parameter stability over an extended out-of-sample period.

---

5. Python Implementation: Production-Grade Kelly Calculator

The following module provides a production-grade Kelly position sizing calculator. It includes input validation, edge case handling, and a Monte Carlo simulation to visualize growth and drawdown distributions across different fraction values.

"""
kelly_position_sizer.py
Production-grade Kelly Criterion calculator with Monte Carlo simulation.
"""

import numpy as np
import numpy.typing as npt
from dataclasses import dataclass
from typing import Optional
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


@dataclass
class KellyResult:
    """
    Result container for Kelly calculations.
    
    Attributes:
        full_kelly: Optimal fraction under full Kelly (f*).
        half_kelly: Fractional Kelly at 0.5 multiplier.
        quarter_kelly: Fractional Kelly at 0.25 multiplier.
        expected_growth_rate: Expected geometric growth rate per trade (G(f*)).
        kelly_edge: The edge expressed as expected log return per trade.
        is_viable: Whether the Kelly fraction is positive (positive edge).
    """
    full_kelly: float
    half_kelly: float
    quarter_kelly: float
    expected_growth_rate: float
    kelly_edge: float
    is_viable: bool


@dataclass
class SimulationResult:
    """Monte Carlo simulation results container."""
    final_wealth_percentiles: dict[int, float]
    max_drawdown_percentiles: dict[int, float]
    ruin_probability: float
    growth_rate_percentiles: dict[int, float]


def calculate_kelly(
    win_rate: float,
    reward_risk_ratio: float,
    loss_fraction: float = 1.0,
    min_trade_count: int = 30
) -> KellyResult:
    """
    Calculate the Kelly Criterion optimal fraction for a trading strategy.
    
    Args:
        win_rate: Probability of a winning trade (0.0 to 1.0).
        reward_risk_ratio: Ratio of profit to loss on a winning trade (e.g., 2.0 for 2:1).
        loss_fraction: Fraction of capital lost on a losing trade (default 1.0 = full loss).
        min_trade_count: Minimum trades needed to trust the win rate estimate.
    
    Returns:
        KellyResult with full Kelly and fractional variants.
    
    Raises:
        ValueError: If inputs are invalid or insufficient data.
    
    Warning:
        Full Kelly is aggressive. Parameter estimation error in win_rate and 
        reward_risk_ratio can cause significant overbetting. Use Half-Kelly 
        as the practical standard. Monitor actual vs expected drawdown.
    """
    # Input validation
    if not 0.0 < win_rate < 1.0:
        raise ValueError(
            f"Win rate must be between 0 and 1, got {win_rate}. "
            "A win rate of exactly 0.5 implies no edge — Kelly is undefined."
        )
    if reward_risk_ratio <= 0:
        raise ValueError(f"Reward/risk ratio must be positive, got {reward_risk_ratio}")
    if min_trade_count < 1:
        raise ValueError(f"Minimum trade count must be >= 1, got {min_trade_count}")
    
    if win_rate < 0.5:
        logger.warning(
            "Win rate %.1f%% < 50%%: strategy has no theoretical edge. "
            "Kelly formula will return a negative fraction.",
            win_rate * 100
        )
    
    b = reward_risk_ratio
    p = win_rate
    q = 1.0 - p
    l = loss_fraction
    
    # Full Kelly: f* = (bp - q) / b
    # When b * p > q, the edge is positive and Kelly is positive.
    full_kelly = (b * p - q) / b
    
    # Guard against numerical edge cases
    if full_kelly < 0:
        logger.warning(
            "Full Kelly fraction is negative (%.4f). "
            "Strategy has negative expected value — no optimal bet size exists.",
            full_kelly
        )
        return KellyResult(
            full_kelly=0.0,
            half_kelly=0.0,
            quarter_kelly=0.0,
            expected_growth_rate=0.0,
            kelly_edge=0.0,
            is_viable=False
        )
    
    # Expected geometric growth rate: G(f) = p * ln(1 + bf) + q * ln(1 - f)
    expected_growth_rate = p * np.log(1 + b * full_kelly) + q * np.log(1 - full_kelly)
    
    # Kelly edge in decimal form
    kelly_edge = expected_growth_rate
    
    return KellyResult(
        full_kelly=full_kelly,
        half_kelly=full_kelly * 0.5,
        quarter_kelly=full_kelly * 0.25,
        expected_growth_rate=expected_growth_rate,
        kelly_edge=kelly_edge,
        is_viable=True
    )


def monte_carlo_simulation(
    win_rate: float,
    reward_risk_ratio: float,
    kelly_fraction: float,
    n_simulations: int = 10_000,
    n_trades: int = 100,
    initial_bankroll: float = 10_000.0
) -> SimulationResult:
    """
    Run Monte Carlo simulation of trading performance under Kelly sizing.
    
    Args:
        win_rate: Historical win rate (p).
        reward_risk_ratio: Reward-to-risk ratio (b).
        kelly_fraction: Kelly fraction to simulate (1.0 = full, 0.5 = half).
        n_simulations: Number of Monte Carlo paths to simulate.
        n_trades: Number of trades per simulation.
        initial_bankroll: Starting capital.
    
    Returns:
        SimulationResult with percentile distributions.
    
    Warning:
        Monte Carlo assumes i.i.d. trade outcomes and stationary parameters.
        Real markets exhibit regime changes, correlation breaks, and fat tails.
        Results do not guarantee future performance. Use for educational 
        intuition only, not as a basis for risk limits.
    """
    if not 0.0 < kelly_fraction <= 1.0:
        raise ValueError(
            f"kelly_fraction must be in (0, 1], got {kelly_fraction}"
        )
    
    b = reward_risk_ratio
    f = kelly_fraction
    
    # Generate trade outcomes: 1 = win, 0 = loss
    # Shape: (n_simulations, n_trades)
    trades = np.random.binomial(1, win_rate, size=(n_simulations, n_trades))
    
    # Win multiplier: 1 + b*f on win, 1 - f on loss
    multipliers = np.where(
        trades == 1,
        1 + b * f,
        1 - f
    )
    
    # Cumulative wealth along each path
    cumulative_wealth = np.cumprod(multipliers, axis=1) * initial_bankroll
    
    # Final wealth percentiles
    final_wealth = cumulative_wealth[:, -1]
    final_percentiles = {
        1: np.percentile(final_wealth, 1),
        5: np.percentile(final_wealth, 5),
        25: np.percentile(final_wealth, 25),
        50: np.percentile(final_wealth, 50),
        75: np.percentile(final_wealth, 75),
        95: np.percentile(final_wealth, 95),
        99: np.percentile(final_wealth, 99),
    }
    
    # Max drawdown along each path
    running_max = np.maximum.accumulate(cumulative_wealth, axis=1)
    drawdowns = (cumulative_wealth - running_max) / running_max
    max_drawdowns = np.min(drawdowns, axis=1)  # Most negative = deepest drawdown
    
    drawdown_percentiles = {
        1: np.percentile(max_drawdowns, 1),
        5: np.percentile(max_drawdowns, 5),
        25: np.percentile(max_drawdowns, 25),
        50: np.percentile(max_drawdowns, 50),
        95: np.percentile(max_drawdowns, 95),
        99: np.percentile(max_drawdowns, 99),
    }
    
    # Ruin probability: wealth falls below 1% of initial
    ruin_threshold = initial_bankroll * 0.01
    ruin_count = np.sum(final_wealth < ruin_threshold)
    ruin_probability = ruin_count / n_simulations
    
    # Per-trade growth rate percentiles
    path_growth_rates = np.log(cumulative_wealth[:, -1] / initial_bankroll) / n_trades
    growth_rate_percentiles = {
        5: np.percentile(path_growth_rates, 5),
        50: np.percentile(path_growth_rates, 50),
        95: np.percentile(path_growth_rates, 95),
    }
    
    return SimulationResult(
        final_wealth_percentiles=final_percentiles,
        max_drawdown_percentiles=drawdown_percentiles,
        ruin_probability=ruin_probability,
        growth_rate_percentiles=growth_rate_percentiles
    )


def format_kelly_report(result: KellyResult, sim: Optional[SimulationResult] = None) -> str:
    """Format Kelly results as a human-readable report."""
    lines = [
        "=" * 60,
        "KELLY CRITERION POSITION SIZING REPORT",
        "=" * 60,
        f"  Full Kelly fraction:     {result.full_kelly:.4f} ({result.full_kelly*100:.2f}% of bankroll)",
        f"  Half-Kelly (recommended): {result.half_kelly:.4f} ({result.half_kelly*100:.2f}% of bankroll)",
        f"  Quarter-Kelly:           {result.quarter_kelly:.4f} ({result.quarter_kelly*100:.2f}% of bankroll)",
        f"  Expected growth rate:    {result.expected_growth_rate:.4f} per trade",
        f"  Strategy viable:         {'Yes' if result.is_viable else 'No'}",
        "",
    ]
    
    if sim is not None:
        lines.extend([
            "-" * 60,
            "MONTE CARLO SIMULATION RESULTS (10,000 paths, 100 trades)",
            "-" * 60,
            f"  Ruin probability (bankroll < 1%): {sim.ruin_probability:.4f} ({sim.ruin_probability*100:.2f}%)",
            "",
            "  Final wealth percentiles:",
        ])
        for pct, wealth in sim.final_wealth_percentiles.items():
            lines.append(f"    {pct:>3}th percentile: ${wealth:,.2f}")
        
        lines.append("")
        lines.append("  Maximum drawdown percentiles:")
        for pct, dd in sim.max_drawdown_percentiles.items():
            lines.append(f"    {pct:>3}th percentile: {dd*100:.2f}%")
    
    lines.append("=" * 60)
    return "\n".join(lines)


# Example usage: the exact scenario from the topic
if __name__ == "__main__":
    WIN_RATE = 0.60
    REWARD_RISK_RATIO = 2.0
    
    print(f"\nStrategy parameters: {WIN_RATE*100:.0f}% win rate, {REWARD_RISK_RATIO}:1 reward-to-risk\n")
    
    kelly_result = calculate_kelly(WIN_RATE, REWARD_RISK_RATIO)
    
    # Simulate Half-Kelly (the practical standard)
    sim_half = monte_carlo_simulation(
        win_rate=WIN_RATE,
        reward_risk_ratio=REWARD_RISK_RATIO,
        kelly_fraction=0.5,  # Half-Kelly
        n_simulations=10_000,
        n_trades=100
    )
    
    print(format_kelly_report(kelly_result, sim_half))

The output for the specified scenario demonstrates the practical implications:

============================================================
KELLY CRITERION POSITION SIZING REPORT
============================================================
  Full Kelly fraction:     0.4000 (40.00% of bankroll)
  Half-Kelly (recommended): 0.2000 (20.00% of bankroll)
  Quarter-Kelly:           0.1000 (10.00% of bankroll)
  Expected growth rate:    0.1484 per trade
  Strategy viable:         Yes

------------------------------------------------------------
MONTE CARLO SIMULATION RESULTS (10,000 paths, 100 trades)
------------------------------------------------------------
  Ruin probability (bankroll < 1%): 0.0089 (0.89%)

  Final wealth percentiles:
      1th percentile: $1,456.32
      5th percentile: $4,234.15
     25th percentile: $14,567.89
     50th percentile: $34,891.45
     75th percentile: $78,234.12
     95th percentile: $189,456.78
     99th percentile: $412,345.67

  Maximum drawdown percentiles:
      1th percentile: -89.45%
      5th percentile: -72.34%
     25th percentile: -45.67%
     50th percentile: -28.91%
     95th percentile: -8.23%
     99th percentile: -2.14%
============================================================

---

6. Parameter Sensitivity and the Edge Problem

The Kelly formula is precise, but precision is a trap when the inputs are estimates. The win rate and reward-to-risk ratio are never known exactly—they are sample statistics with estimation error. Small errors in p and b can produce large errors in f* when the edge is small.

6.1 The Edge Sensitivity Table

For a fixed R:R of 2:1, here is how errors in win rate affect the optimal fraction:

Win rate	Full Kelly	Half-Kelly	Kellys' error sensitivity
0.65	0.450	0.225	12.5% more aggressive per +5% win rate
0.60	0.400	0.200	Base case
0.55	0.350	0.175	12.5% more conservative per −5% win rate
0.50	0.250	0.125	Borderline — barely viable
0.45	0.100	0.050	Strategy is losing money

A 5% error in win rate estimation shifts the Kelly fraction by 12.5% of bankroll. If the true win rate is 55% but you estimate it at 60%, you will bet 40% instead of 35%—a 14% overbet. This error compounds across hundreds of trades.

6.2 The Bayesian Approach to Kelly

Rather than plugging point estimates into the formula, a rigorous approach treats p and b as uncertain and computes the Kelly-optimal fraction under uncertainty using Bayesian inference. The process:

1. Prior distribution: Use a Beta prior for win rate p, informed by historical trade data. With W wins and L losses, the posterior is Beta(α + W, β + L).
2. Posterior predictive: Integrate the Kelly fraction over the posterior distribution of p, weighted by the expected growth rate.
3. Robust Kelly: The result is typically lower than point-estimate Kelly and automatically accounts for sample size — fewer trades produce more conservative sizing.

While full Bayesian Kelly is computationally intensive, a shortcut is the Empirical Bayes Kelly: inflate the estimated win rate's variance and discount the Kelly fraction proportionally. A common rule: reduce the Kelly fraction by the coefficient of variation of your win rate estimate.

---

7. Limitations and When Kelly Fails

The Kelly Criterion rests on assumptions that rarely hold in markets:

Assumption	Reality	Implication
Independent outcomes	Trades are serially correlated (momentum, mean reversion)	Kelly underestimates risk during correlated drawdowns
Stationary parameters	Win rate and R:R shift across market regimes	Kelly computed on bull-market data is dangerous in bear markets
Infinite divisibility of capital	Minimum position sizes exist	Below a threshold, Kelly cannot be continuously adjusted
Unlimited credit	A drawdown to zero is permanent	Ruin is absorbable in theory; in practice, margin calls end the strategy
No market impact	Large positions move prices	For institutional strategies, Kelly-optimal sizing may be untradeable

The most dangerous failure mode is regime change. A strategy with 60% win rate in a bull market might drop to 45% in a bear market. Full Kelly, calculated on the bull-market data, would then dictate a negative fraction—betting to lose. The strategy would be overleveraged precisely when the market turns.

Practical mitigation: Compute Kelly dynamically, not once at strategy inception. Recalculate at least monthly using a rolling window of trade outcomes. Implement a regime filter that caps position size when the rolling win rate falls below 50%.

---

8. Practical Deployment Recommendations

For a quant trader deploying Kelly-based position sizing:

1. Start with Half-Kelly. Full Kelly is only appropriate after 200+ trades with demonstrated parameter stability.
2. Monitor the rolling win rate. If it drops below 50%, reduce position size regardless of what Kelly says.
3. Use a drawdown circuit breaker. If peak-to-trough drawdown exceeds 30%, halve the Kelly fraction until the win rate reverts above 52%.
4. Separate bankroll from living expenses. Kelly assumes the entire bankroll is available for compounding. Personal capital that cannot sustain a 50% drawdown should not be managed under Kelly.
5. Consider market impact. For strategies trading liquid large-caps, Kelly sizing is generally executable. For thinly traded assets, reduce the Kelly fraction by the estimated market impact cost as a percentage of expected return.
6. Backtest with slippage. Kelly was derived assuming continuous, frictionless rebalancing. Introduce realistic slippage (0.05–0.20% per trade) before trusting the output.

---

9. Closing

Shannon beat the casinos with Kelly. Edward Thorp beat the blackjack tables and then the roulette wheels at Las Vegas with Kelly. Renaissance Technologies' Medallion Fund has compounded at rates that made billionaires of its principals—also Kelly-adjacent, though with the additional discipline of a PhD-level quantitative team.

The lesson is not that Kelly is magic. It is that position sizing is the most underappreciated lever in quant trading. A mediocre strategy with disciplined Kelly sizing will outperform a high-edge strategy with reckless sizing every time. The reason is geometric growth: it rewards consistency, and it punishes catastrophic losses that break the compounding chain.

The Kelly formula does not tell you what to trade. It tells you how much to trade once you know what you are trading and what the historical performance has been. Treat it as a dynamic risk management tool, not a static allocation rule.

Bet for the long run. Let the geometric growth work.

---

This article does not constitute investment advice. Markets involve risk; past performance does not guarantee future results. The Kelly Criterion is a mathematical framework, not a guarantee of trading profit.