Optimal position sizing for prediction markets, equities, options, and crypto with Rust-native Kelly criterion functions. Single, fractional, multi-asset, and liquidity-adjusted Kelly.
Horizon includes a complete suite of Kelly criterion functions for optimal position sizing in prediction markets, equities, options, and crypto. All functions are implemented in Rust for maximum performance and exposed to Python via PyO3.
The Kelly criterion tells you the theoretically optimal fraction of your bankroll to wager given your edge. In practice, fractional Kelly (typically 0.25x to 0.5x) is preferred to reduce variance and account for estimation error.
Kelly works for any binary outcome with a known probability and price — prediction market contracts, stock directional bets, option payoffs, or crypto positions. The math is the same: estimate the true probability, compare to the market-implied price, and size accordingly.
fraction = hz.kelly(0.65, 0.55)print(f"Kelly fraction: {fraction:.4f}") # Optimal % of bankroll to bet
Formula: (fair_prob * (1 - market_price) - (1 - fair_prob) * market_price) / (1 - market_price)If the result is negative, there is no edge on the Yes side.
Half-Kelly (fraction=0.5) is the most common choice in practice. It achieves 75% of the growth rate of full Kelly while cutting variance in half. Quarter-Kelly (fraction=0.25) is even more conservative and suitable when your probability estimates are noisy.
Optimal sizing across multiple simultaneous positions.
Copy
probs = [0.65, 0.40, 0.75] # Your estimated probabilitiesprices = [0.55, 0.30, 0.60] # Current market pricessizes = hz.multi_kelly(probs, prices, 1.0)for i, size in enumerate(sizes): print(f"Position {i+1}: fraction={size:.4f}")
Parameter
Type
Description
probs
list[float]
Your estimated probabilities for each market
prices
list[float]
Current market prices for each market
max_total
float
Maximum total Kelly fraction across all positions
multi_kelly returns Kelly fractions (not contract sizes). The sum of fractions will not exceed max_total. This is preferred over calling kelly independently for each position, which could over-allocate capital.
The function computes a raw Kelly size then scales it down using a square-root dampening factor based on the ratio of available liquidity to the raw size. The result is capped at both max_size and available_liquidity.
Factory function that returns a pipeline-compatible sizing function for use with hz.run().
Copy
sizer = hz.kelly_sizer(fraction=0.25, bankroll=10000.0, max_size=100.0)# Use in a pipeline - the returned function takes (ctx, estimated_prob)hz.run( name="my-strategy", markets=["some-market"], feeds={"some-market": "polymarket_book"}, pipeline=[estimate_prob, sizer, to_quotes],)
Parameter
Type
Default
Description
fraction
float
0.25
Kelly multiplier
bankroll
float
1000.0
Total available capital
max_size
float
100.0
Hard cap on position size
Returns a callable (Context, float) -> float that extracts the market price from ctx.feeds and calls hz.kelly_size() internally.
Like kelly_sizer but adjusts for available liquidity using hz.liquidity_adjusted_kelly().
Copy
sizer = hz.kelly_sizer_with_liquidity(fraction=0.25, bankroll=10000.0, max_size=100.0)# Use in a pipelinehz.run( name="my-strategy", markets=["some-market"], feeds={"some-market": "polymarket_book"}, pipeline=[estimate_prob, sizer, to_quotes],)
Parameter
Type
Default
Description
fraction
float
0.25
Kelly multiplier
bankroll
float
1000.0
Total available capital
max_size
float
100.0
Hard cap on position size
Returns a callable (Context, float) -> float that extracts both market price and available liquidity from ctx and calls hz.liquidity_adjusted_kelly() internally.
import horizon as hzfair = 0.70price = 0.58bankroll = 10000.0# Without liquidity adjustment (prob, market_price, bankroll, fraction, max_size)naive_size = hz.kelly_size(fair, price, bankroll, 0.5, 10000.0)print(f"Naive Kelly size: {naive_size:.0f} contracts")# With liquidity adjustment# Only 200 contracts available near the current price# (prob, market_price, bankroll, fraction, available_liquidity, max_size)adjusted_size = hz.liquidity_adjusted_kelly(fair, price, bankroll, 0.5, 200.0, 10000.0)print(f"Liquidity-adjusted size: {adjusted_size:.0f} contracts")# Will be scaled down based on available liquidity
For a binary outcome (Yes/No) with market price p and your estimated probability q:Yes Kelly fraction = (q * (1-p) - (1-q) * p) / (1-p)No Kelly fraction = ((1-q) * p - q * (1-p)) / pThis maximizes the expected logarithm of wealth (geometric growth rate).
Why Fractional Kelly?
Full Kelly is optimal only if:
Your probability estimates are perfectly calibrated
You have infinite time horizon
You can tolerate extreme drawdowns
In practice, none of these hold. Fractional Kelly (f < 1.0) provides:
Lower variance (proportional to f^2)
Lower drawdowns
Robustness to estimation error
Only marginally lower expected growth (at half-Kelly, growth is 75% of full Kelly)
Multi-Position Kelly
When holding multiple positions, independent Kelly calculations can over-allocate capital. hz.multi_kelly() solves the joint optimization problem, ensuring total allocation respects the bankroll constraint.
Kelly sizing assumes your probability estimates are accurate. If your model is poorly calibrated, Kelly will aggressively over-size positions. Always validate calibration using hz.backtest() with the outcomes parameter before deploying Kelly sizing in production.
