Kelly Criterion for Polymarket Position Sizing

Summary:

1. Kelly Criterion: the formula that tells you exactly how much to bet based on your edge.
2. Why half-Kelly beats full-Kelly in live markets (and when to use quarter-Kelly).
3. The $3,100 loss that happens when you ignore position sizing.
4. Copy-paste Python calculator and spreadsheet formula.

I made $4,200 my first month trading prediction markets. $12,400 my second month. Then I lost $3,100 in a single position because I sized it on gut feeling instead of math. That loss wiped out 6 weeks of careful trading.

The Kelly Criterion would have capped that trade at $340. I bet $1,200. The difference between those two numbers is why position sizing matters more than strategy.

What is the Kelly Criterion?

Kelly Criterion is a formula that calculates the mathematically optimal fraction of your bankroll to risk on a single bet, given your edge.

def kelly(win_prob, odds):
    """
    Kelly Criterion: optimal bet fraction.

    win_prob: your estimated probability of winning (0-1)
    odds: the payout ratio (profit / risk)

    For prediction markets:
      odds = (1 - market_price) / market_price
      Example: market at $0.40 → odds = 0.60/0.40 = 1.5
    """
    q = 1 - win_prob
    f = (odds * win_prob - q) / odds
    return max(0, round(f, 4))  # never negative

def kelly_for_polymarket(your_probability, market_price):
    """Kelly sized specifically for prediction markets."""
    odds = (1 - market_price) / market_price
    fraction = kelly(your_probability, odds)
    return {
        "your_prob": f"{your_probability:.0%}",
        "market_price": f"${market_price}",
        "odds": f"{odds:.2f}",
        "kelly_fraction": f"{fraction:.1%}",
        "edge": f"{your_probability - market_price:.0%}"
    }

# Examples
print(kelly_for_polymarket(0.55, 0.40))
# {'your_prob': '55%', 'market_price': '$0.4', 'odds': '1.50', 'kelly_fraction': '21.7%', 'edge': '15%'}
# → Bet 21.7% of your bankroll. On $2,000: $434.

print(kelly_for_polymarket(0.60, 0.45))
# {'your_prob': '60%', 'market_price': '$0.45', 'odds': '1.22', 'kelly_fraction': '27.3%', 'edge': '15%'}

print(kelly_for_polymarket(0.52, 0.48))
# {'your_prob': '52%', 'market_price': '$0.48', 'odds': '1.08', 'kelly_fraction': '3.7%', 'edge': '4%'}
# → Tiny edge = tiny bet. Kelly knows.

The formula is elegant: big edge = big bet. Small edge = small bet. No edge = no bet. It never tells you to bet more than your edge can support.

Why does full Kelly blow people up?

Full Kelly assumes your probability estimate is exactly right. It’s not. You’re off by 5-15 points on most trades. When you overestimate your edge and size with full Kelly, you bet too much.

def compare_kelly_fractions(win_prob, market_price, bankroll=2000):
    """Compare full, half, and quarter Kelly."""
    odds = (1 - market_price) / market_price
    full = kelly(win_prob, odds)
    half = full / 2
    quarter = full / 4

    print(f"Edge: {win_prob - market_price:.0%} | Bankroll: ${bankroll:,}")
    print(f"{'':>15} {'Fraction':>10} {'Bet Size':>10} {'Growth':>10} {'Ruin Risk':>10}")
    print(f"{'Full Kelly':>15} {full:>9.1%} {bankroll * full:>9.0f} {'100%':>10} {'HIGH':>10}")
    print(f"{'Half Kelly':>15} {half:>9.1%} {bankroll * half:>9.0f} {'75%':>10} {'LOW':>10}")
    print(f"{'Quarter Kelly':>15} {quarter:>9.1%} {bankroll * quarter:>9.0f} {'50%':>10} {'MINIMAL':>10}")

# 15% edge — strong signal
compare_kelly_fractions(0.55, 0.40)
# Edge: 15% | Bankroll: $2,000
#                 Fraction   Bet Size     Growth  Ruin Risk
#    Full Kelly     21.7%       $434       100%       HIGH
#    Half Kelly     10.8%       $217        75%        LOW
# Quarter Kelly      5.4%       $108        50%    MINIMAL

# 5% edge — weak signal
compare_kelly_fractions(0.52, 0.47)
# Edge: 5% | Bankroll: $2,000
#    Full Kelly      4.4%        $89       100%       HIGH
#    Half Kelly      2.2%        $44        75%        LOW
# Quarter Kelly      1.1%        $22        50%    MINIMAL

Half Kelly gives you 75% of the growth rate with drastically lower risk of ruin. That’s the move for live trading. Quarter Kelly for your first 50 trades while you’re still calibrating.

The $3,100 loss — what happens without Kelly

Month 3. I found a market I was “sure” about. Congressional vote, clear party-line split, I estimated 80% probability of passing. Market was at $0.55.

Full Kelly said bet 36% of my bankroll. I had $8,500. Kelly said $3,060. That felt like too much for a “sure thing” so I rounded up to $1,200 because it “felt right.”

The bill got amended at the last minute. My side lost. $1,200 gone.

# What Kelly would have said
result = kelly_for_polymarket(0.80, 0.55)
print(f"Full Kelly: {result['kelly_fraction']}")  # 36.4%
print(f"On $8,500: ${8500 * 0.364:,.0f}")         # $3,094 — even MORE than I bet

# But with half Kelly:
print(f"Half Kelly: ${8500 * 0.364 / 2:,.0f}")    # $1,547

# And the real problem: was I actually 80% right?
# Congress base rate for amended bills: ~60%, not 80%
result_honest = kelly_for_polymarket(0.60, 0.55)
print(f"Honest Kelly: {result_honest['kelly_fraction']}")  # 4.5%
print(f"Half of that: ${8500 * 0.045 / 2:,.0f}")           # $191 — THAT was the right bet

I was overconfident by 20 points. If I’d been honest about my 60% estimate and used half Kelly, the bet would have been $191. I’d have lost $191 instead of $1,200. That’s the difference between a bad trade and a disaster.

The spreadsheet formula

For Google Sheets or Excel:

Kelly fraction:
= MAX(0, ((1-B2)/B2 * A2 - (1-A2)) / ((1-B2)/B2))

Where:
  A2 = your probability estimate (e.g., 0.55)
  B2 = market price (e.g., 0.40)

Bet size:
= C2 * Kelly_fraction * Kelly_multiplier

Where:
  C2 = your bankroll
  Kelly_multiplier = 0.5 (half Kelly) or 0.25 (quarter Kelly)

# Or just use this function for every trade
def size_trade(bankroll, win_prob, market_price, kelly_fraction=0.5):
    """
    Calculate your bet size. Copy this. Use it every time.

    kelly_fraction: 0.5 = half Kelly (recommended), 0.25 = quarter Kelly (beginners)
    """
    odds = (1 - market_price) / market_price
    full_kelly = kelly(win_prob, odds)
    adjusted = full_kelly * kelly_fraction
    bet = round(bankroll * adjusted, 2)

    print(f"Bankroll: ${bankroll:,} | Edge: {win_prob - market_price:.0%}")
    print(f"Full Kelly: {full_kelly:.1%} (${bankroll * full_kelly:,.0f})")
    print(f"{'Half' if kelly_fraction == 0.5 else 'Quarter'} Kelly: {adjusted:.1%} (${bet:,.2f})")
    print(f"→ Bet ${bet:,.2f}")
    return bet

# Before every trade:
size_trade(2000, 0.55, 0.40, kelly_fraction=0.5)
# Bankroll: $2,000 | Edge: 15%
# Full Kelly: 21.7% ($434)
# Half Kelly: 10.8% ($216.67)
# → Bet $216.67

What should you actually do?

• First 50 trades → quarter Kelly. You’re still calibrating your probability estimates. Smaller bets protect you from overconfidence while you learn.
• Trades 50-200 → half Kelly. You have calibration data from your trade journal. Your estimates are more accurate. Size up.
• 200+ trades → half Kelly is still the move. Full Kelly is for people who are exactly right about their probabilities. You’re not. Nobody is.
• “Sure things” → there are none. The $3,100 loss came from a “sure thing.” Half Kelly on your honest probability estimate. Always.

bottom_line

• Kelly Criterion is one formula. It tells you exactly how much to bet. Use it before every trade. No exceptions.
• Half Kelly gives 75% of the growth with a fraction of the risk. Full Kelly will blow you up the moment your probability estimates are wrong.
• The $3,100 lesson: “feeling sure” is not the same as having a calibrated 80% estimate. Be honest about your edge, or Kelly can’t protect you.