Menu
Kelly criterion optimal sizing with fractional variants, edge estimation, and practical application for crypto trading
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Kalshi exchange mechanics — RSA-PSS auth, order schema, YES/NO orderbook convention, WebSocket, and endpoint surface. Market-type-agnostic shared layer for all Kalshi skills.
Kalshi daily and hourly range markets on crypto prices (BTC, ETH) and equity indices (S&P 500, Nasdaq-100) — bracket structure, Gaussian P(YES) modeling on price/vol, close-offset decision timing, longshot-sell edge with honest evidence bounds
Daily temperature high/low bracket and threshold contracts on Kalshi — contract structure, forecast→P(YES) map, settlement rules, cross-venue divergences, and weather-specific pitfalls
Polymarket exchange mechanics — on-chain Polygon CTF, Gamma/CLOB/Data APIs, EIP-712 auth, identifier model, WebSocket, settlement, and geo/KYC constraint
Venue- and market-type-agnostic strategy, sizing, and backtesting layer for binary prediction markets (Kalshi, Polymarket, ForecastEx). Covers the durable edge thesis, fee-aware selection, fractional-Kelly sizing, and leak-free validation methodology.
Portfolio-level risk controls, drawdown management, exposure limits, and circuit breakers for crypto trading
| name | kelly-criterion |
| description | Kelly criterion optimal sizing with fractional variants, edge estimation, and practical application for crypto trading |
The Kelly criterion is the mathematically optimal bet size that maximizes long-term geometric growth of capital. Developed by John Kelly at Bell Labs in 1956, it answers a precise question: given a known edge, what fraction of your bankroll should you risk to maximize the compounding rate?
Core insight: Betting too small leaves growth on the table. Betting too large increases ruin risk and actually reduces long-term growth. Kelly finds the exact optimum between these extremes.
Practical insight: You should almost never use full Kelly. Estimation error in your edge means full Kelly will overbets in practice. Use fractional Kelly (0.25x to 0.5x) for real trading.
For a binary outcome (win or lose):
f* = (p * b - q) / b
Where:
f* = optimal fraction of bankroll to betp = probability of winningq = probability of losing (1 - p)b = payoff ratio (average win / average loss)Equivalent forms:
f* = p - q / b
f* = p - (1 - p) / b
f* = (p * b - (1 - p)) / b
Edge = p * b - q = expected value per unit risked. Kelly only makes sense when edge > 0. If edge is zero or negative, the optimal bet is zero — do not trade.
| Win Rate | Payoff 1:1 | Payoff 1.5:1 | Payoff 2:1 | Payoff 3:1 |
|---|---|---|---|---|
| 40% | -20% | -6.7% | 10% | 20% |
| 45% | -10% | 3.3% | 15% | 25% |
| 50% | 0% | 16.7% | 25% | 33.3% |
| 55% | 10% | 18.3% | 27.5% | 35% |
| 60% | 20% | 26.7% | 35% | 40% |
Values are full Kelly fraction. In practice, use 0.25x to 0.5x of these numbers.
Full Kelly assumes you know p and b exactly. You never do. Here is why fractional Kelly is essential:
Your win rate estimate from 100 trades has a standard error of roughly ±5%. If your true win rate is 55% but you estimate 60%, full Kelly will overbets by ~50%, which reduces long-term growth below what half Kelly would achieve.
Full Kelly has extremely high variance. Expected maximum drawdown for full Kelly is roughly 50-80% of account. This is psychologically devastating and practically dangerous (margin calls, inability to continue trading).
| Kelly Fraction | Relative Growth Rate | Approximate Max Drawdown |
|---|---|---|
| 1.0x (full) | 100% | 50-80% |
| 0.5x (half) | ~75% | 25-40% |
| 0.25x (quarter) | ~50% | 12-20% |
| 0.1x (tenth) | ~25% | 5-10% |
Overbetting by 2x (betting at 2f) produces zero long-term growth — the same as not trading at all. Underbetting by 2x (betting at 0.5f) still captures ~75% of the optimal growth rate. The penalty for overbetting is catastrophically worse than for underbetting.
| Fraction | When to Use |
|---|---|
| 0.10x Kelly | Very uncertain edge, new strategy, < 30 trades in sample |
| 0.25x Kelly | Moderate confidence, 30-100 trades, reasonable Sharpe |
| 0.50x Kelly | High confidence, 100+ trades, consistent performance |
| 1.00x Kelly | Never recommended in practice |
Kelly requires two inputs: win rate (p) and payoff ratio (b). Both must be estimated from data.
wins = [t for t in trades if t > 0]
losses = [t for t in trades if t < 0]
win_rate = len(wins) / len(trades) # p
payoff_ratio = mean(wins) / abs(mean(losses)) # b
edge = win_rate * payoff_ratio - (1 - win_rate) # should be > 0
kelly_full = (win_rate * payoff_ratio - (1 - win_rate)) / payoff_ratio
Use the lower bound of a Wilson confidence interval for win rate rather than the point estimate:
import math
def wilson_lower(wins: int, total: int, z: float = 1.96) -> float:
"""Lower bound of Wilson score interval (95% confidence)."""
p = wins / total
denominator = 1 + z**2 / total
centre = p + z**2 / (2 * total)
spread = z * math.sqrt((p * (1 - p) + z**2 / (4 * total)) / total)
return (centre - spread) / denominator
Using the lower bound of the confidence interval for win rate automatically builds in conservatism, reducing the risk of overbetting due to sampling luck.
| Edge Value | Classification | Notes |
|---|---|---|
| < 0 | Negative edge | Do not trade this strategy |
| 0 - 0.02 | No meaningful edge | Transaction costs likely exceed edge |
| 0.02 - 0.10 | Marginal edge | Conservative fractions only |
| 0.10 - 0.20 | Good edge | Standard fractions appropriate |
| > 0.20 | Excellent edge | Rare; verify not overfitting or temporary |
When holding multiple positions simultaneously:
If bets are uncorrelated, each can be sized at its individual Kelly fraction. However, the sum of all Kelly fractions should not exceed 1.0 (total portfolio). If it does, scale each proportionally:
kelly_fractions = [0.15, 0.10, 0.12, 0.08] # individual Kelly fractions
total = sum(kelly_fractions) # 0.45
if total > 1.0:
scale = 1.0 / total
kelly_fractions = [f * scale for f in kelly_fractions]
Correlated positions (e.g., multiple SOL memecoins) are effectively one larger bet. Reduce each position proportionally to the correlation:
# Simple correlation adjustment
def adjust_for_correlation(kelly_fractions: list, avg_correlation: float) -> list:
"""Reduce Kelly fractions based on average inter-position correlation."""
n = len(kelly_fractions)
# Effective number of independent bets
n_eff = n / (1 + (n - 1) * avg_correlation)
scale = n_eff / n
return [f * scale for f in kelly_fractions]
In crypto, meme token positions often have correlations of 0.5-0.8 with each other (they all dump together in risk-off). Treat them as partially one bet.
Regardless of individual calculations, enforce a hard cap: total Kelly allocation should never exceed 1.0 (100% of portfolio). A practical maximum is 0.6-0.8 to leave cash buffer for drawdowns and new opportunities.
Meme token trading presents specific challenges for Kelly:
def meme_kelly(win_rate: float, payoff_ratio: float, account: float) -> float:
"""Conservative Kelly for high-uncertainty meme token trades."""
kelly_full = (win_rate * payoff_ratio - (1 - win_rate)) / payoff_ratio
kelly_conservative = kelly_full * 0.15 # 0.15x fractional
max_fraction = 0.05 # hard cap at 5%
return min(max(kelly_conservative, 0), max_fraction) * account
Kelly optimality relies on assumptions that are often violated:
| Assumption | Reality | Impact |
|---|---|---|
| Known edge (p, b) | Estimated from noisy data | Overbetting risk |
| Independent bets | Correlated positions | Ruin risk increases |
| Binary outcomes | Continuous P&L distribution | Formula approximation |
| Stationary edge | Edge changes over time | Stale sizing |
| No transaction costs | Slippage, fees, MEV | Effective edge lower |
| Unlimited divisibility | Minimum position sizes | Rounding needed |
references/kelly_derivation.md)When returns are continuous rather than binary win/lose:
f* = (μ - r) / σ²
Where:
μ = expected return of the strategyr = risk-free rate (often 0 for crypto)σ² = variance of returnsThis is equivalent to Sharpe² / (2 * σ) when the Sharpe ratio is computed as (μ - r) / σ.
Use this form when you have a return stream rather than discrete win/loss trades. See references/kelly_derivation.md for the full derivation.
position-sizing: Kelly provides the optimal fraction; position-sizing translates that into units. Use Kelly as one input, then apply liquidity and volatility constraints from position-sizing.risk-management: Kelly sizing must respect portfolio-level risk limits. If Kelly suggests 10% per trade but your risk policy caps at 5%, the cap wins.strategy-framework: Document your Kelly parameters (fraction used, sample size, recalculation frequency) as part of strategy specification.regime-detection: Recalculate Kelly when regime changes. Edge in a trending market differs from edge in a ranging market.references/kelly_derivation.md — Full mathematical derivation of Kelly criterion, fractional Kelly growth rates, continuous Kelly, and multi-outcome Kellyreferences/practical_kelly.md — Edge estimation from trading data, confidence intervals, worked examples, common pitfalls, and danger zonesscripts/kelly_calculator.py — Kelly calculator from win rate, payoff ratio, and account size. Prints fractional Kelly recommendations and sensitivity analysis. Dependencies: none.scripts/kelly_from_trades.py — Estimate Kelly from a list of trade P&L values. Computes confidence intervals, rolling stability analysis, and recommended fraction. Dependencies: numpy.