A priest who feared death invented the formula that beats...
A priest who feared death invented the formula that beats prediction markets. A telephone engineer at Bell Labs created the sizing system that protects your bankroll. Two economists built a pricing model that accidentally revealed where Polymarket misprices risk every single day.
> These formulas are 51, 70, and 263 years old.
None of them were designed for prediction markets. One was scribbled in a notebook that wasn't published until after its author died. Another was written for gambling on horses. The third broke Wall Street so badly that its creators had to be bailed out by the Federal Reserve.
And right now, the top 1% of Polymarket traders are quietly running all three combined on every market they enter
Formulas that help them win:
Formula #1: Bayes' Theorem (1763)
The Priest Who Feared Death
Thomas Bayes was an English minister who was, by all accounts, mediocre at his job. His congregation in Tunbridge Wells was small. His published work was thin. He died in 1761 largely unremarkable.
But in his private notebooks, investigators found something after his death: a solution to a problem that had haunted mathematicians for a generation.
The problem: how do you reason under uncertainty when new information arrives?
The classic example Bayes used was a billiard table. You can't see the table. Someone rolls a ball and tells you where it landed. How do you update your belief about where the ball is?
Bayes' answer was elegant: your new belief should be proportional to how likely the evidence would be if your theory were true.
His friend Richard Price sent the paper to the Royal Society in 1763 two years after Bayes died. The paper sat mostly ignored for another 200 years.
Then the nuclear scientists found it. Then the CIA used it to analyze Soviet missile programs. Then Google used it to filter spam.
And now it's the most important formula on Polymarket.
The Formula:
P(A|B) = [P(B|A) × P(A)] / P(B)
Where:
How It Works on Polymarket:
Every day, news breaks. Polls come out. Court decisions land. Data releases hit. Most traders react emotionally. They see a headline and either panic-sell or FOMO-buy.
Bayesian traders do something different: they treat every new piece of information as an update not a verdict.
Real example:
A market: "Will the Fed cut rates in March?" is trading at 42¢. New data arrives: CPI comes in hotter than expected. Emotional trader: "Inflation is bad, the Fed won't cut, sell everything."
```python
# Prior: 42% chance of March cut
prior = 0.42
# How likely was this hot CPI reading IF a March cut was coming?
# Hot CPI makes cuts less likely, so this evidence is rare given a cut scenario
p_evidence_given_cut = 0.15
# How likely was this hot CPI reading in general?
# Hot CPI has been happening ~35% of months recently
p_evidence = 0.35
# Bayes update:
posterior = (p_evidence_given_cut * prior) / p_evidence
# posterior = (0.15 × 0.42) / 0.35 = 0.18
```The market is still at 42¢. Your model says 18¢. That's a 24-cent edge.
You don't sell because of fear. You sell because the math told you to before the market moved.
The Full Python Implementation:
```python
def bayes_update(prior, p_evidence_given_true, p_evidence_given_false):
"""
Update probability after observing new evidence.
prior: your starting probability (0 to 1)
p_evidence_given_true: how likely is this evidence if the outcome is YES
p_evidence_given_false: how likely is this evidence if the outcome is NO
"""
# Total probability of seeing this evidence
p_evidence = (p_evidence_given_true * prior) + \
(p_evidence_given_false * (1 - prior))
# Posterior probability (Bayes theorem)
posterior = (p_evidence_given_true * prior) / p_evidence
return posterior
# Example: "Will Trump win the debate?" market at 65¢
# New evidence: CNN snap poll shows him losing 58-42
prior = 0.65
p_bad_poll_if_win = 0.20 # Unlikely if he actually wins
p_bad_poll_if_lose = 0.75 # Very likely if he actually loses
new_probability = bayes_update(prior, p_bad_poll_if_win, p_bad_poll_if_lose)
print(f"Updated probability: {new_probability:.1%}")
# Output: Updated probability: 33.0%
# Market is at 65¢. Math says 33¢. 32-cent edge.
# Chain multiple updates (Bayes can be applied repeatedly)
# Second evidence: his campaign manager quits the same night
prior2 = new_probability
p_quit_if_win = 0.05
p_quit_if_lose = 0.40
final_probability = bayes_update(prior2, p_quit_if_win, p_quit_if_lose)
print(f"After second update: {final_probability:.1%}")
# Output: After second update: 11.3%
```The Key Insight Most Traders Miss. The power of Bayes isn't one update. It's the chain.
Each new piece of information updates the posterior, which becomes the prior for the next update. By the time the market has processed one headline, a Bayesian trader is already three updates ahead.
This is why Polymarket's best political traders can tell you their exact probability hours before the market converges there. They're not smarter. They're updating continuously while everyone else is reacting emotionally to the same data.
Best Polymarket traders using Bayesian frameworks:
Formula #2: Kelly Criterion (1956)
The Phone Company Employee Who Beat Every Casino
In 1956, John Kelly Jr. was working at Bell Telephone Laboratories in New Jersey, trying to solve a problem in information theory. His job had nothing to do with gambling.
But Kelly noticed something. The problem of how much noise corrupts a signal over a telephone wire is mathematically identical to the problem of how much of your bankroll to bet when you have an edge.
He published his paper "A New Interpretation of Information Rate" in the Bell System Technical Journal. Gamblers found it within months.
Ed Thorp, the man who later counted cards in Vegas and then ran one of the most successful hedge funds in history, called Kelly's formula "the most important betting principle ever discovered."
The casinos hated it. Before Kelly, gamblers with edge still went broke because they bet too much on good hands and too little on great ones. Kelly solved this.
The Formula:
f* = (bp - q) / b
Where:
f* = fraction of bankroll to bet
b = net odds received (e.g., bet 1¢ to win 1¢ → b = 1)
p = probability of winning
q = probability of losing (1 - p)
For binary outcomes (like Polymarket), this simplifies to:
f* = p - (1 - p) / (payout / cost - 1)
Why This Is Lethal Without Kelly:
Consider a trader who found a market with genuine 60% edge. The contract is at 40¢ and they believe it should be 60¢.
Without Kelly, they might bet 30% of their bankroll because it "feels right"
With Kelly, the math says something very different:
```python
def kelly_fraction(p_win, price_cents):
"""
Calculate optimal Kelly bet fraction for a Polymarket binary contract.
p_win: your estimated probability of YES (0 to 1)
price_cents: current market price in cents (0 to 100)
"""
cost = price_cents / 100 # What you pay per share
payout = 1.0 # What you receive if YES resolves
if cost >= payout:
return 0 # No edge
b = (payout - cost) / cost # Net odds
p = p_win
q = 1 - p_win
f = (b * p - q) / b
return max(0, f) # Never negative
# Example: Market at 40¢, you believe true probability is 60%
f = kelly_fraction(p_win=0.60, price_cents=40)
print(f"Kelly says bet: {f:.1%} of bankroll")
# Output: Kelly says bet: 26.7% of bankroll
# Example: Market at 70¢, you believe true probability is 80%
f2 = kelly_fraction(p_win=0.80, price_cents=70)
print(f"Kelly says bet: {f2:.1%} of bankroll")
# Output: Kelly says bet: 9.5% of bankroll
# Example: Market at 80¢, you believe true probability is 82%
f3 = kelly_fraction(p_win=0.82, price_cents=80)
print(f"Kelly says bet: {f3:.1%} of bankroll")
# Output: Kelly says bet: 2.5% of bankroll — tiny edge, tiny bet
```Fractional Kelly: The Practical Adjustment
Full Kelly is mathematically optimal for maximizing long-run returns. But it's emotionally brutal a string of losses at full Kelly feels catastrophic even when the math is working.
Most professional traders use Quarter-Kelly (0.25×):
```python
def quarter_kelly(p_win, price_cents, bankroll):
"""Full position size using quarter-Kelly."""
f = kelly_fraction(p_win, price_cents)
full_kelly_dollars = bankroll * f
quarter_kelly_dollars = full_kelly_dollars * 0.25
shares = quarter_kelly_dollars / (price_cents / 100)
return {
"full_kelly_pct": f,
"quarter_kelly_dollars": quarter_kelly_dollars,
"shares_to_buy": int(shares)
}
# $10,000 bankroll, market at 35¢, you believe 55%
result = quarter_kelly(0.55, 35, 10000)
print(f"Full Kelly: {result['full_kelly_pct']:.1%}")
print(f"Quarter Kelly: ${result['quarter_kelly_dollars']:.0f}")
print(f"Shares: {result['shares_to_buy']}")
# Output:
# Full Kelly: 34.3%
# Quarter Kelly: $857
# Shares: 2449
```The Insight That Makes This Powerful
Kelly's formula does something no intuition can do: it automatically scales your bets with your edge.
Tiny edge? Tiny bet. Massive edge? Large bet but never so large you go broke on a loss streak.
The mathematics guarantee that a Kelly bettor's bankroll grows geometrically over time, while any other strategy produces suboptimal growth (or ruin).
Every time you bet more than Kelly says, you are mathematically destroying your long-run returns. Not maybe. Not sometimes. Every. Single. Time.
Best Polymarket traders using Kelly-based sizing:
Formula #3: Black-Scholes (1973)
The Two Economists Who Broke Wall Street
In 1973, Fischer Black and Myron Scholes published "The Pricing of Options and Corporate Liabilities" in the Journal of Political Economy.
The paper was rejected twice before publication. One reviewer said it was "too financial" for an economics journal. Another said it wasn't general enough.
It would go on to win the Nobel Prize:
The formula told traders, for the first time, exactly what an option contract should be worth based on the underlying asset's volatility, the time remaining, and the strike price.
Wall Street adopted it instantly. Within a year, trading volumes exploded because buyers and sellers finally had a shared language for pricing risk.
Then in 1998, Long-Term Capital Management a hedge fund run by Black-Scholes themselves plus two other Nobel laureates used the formula to leverage $125 billion and nearly collapsed the global financial system. The Federal Reserve had to organize a $3.6 billion bailout.
The formula was correct. The position sizing was insane
Why This Applies to Polymarket:
Black-Scholes was built for options contracts that can expire at any value along a range. Polymarket contracts are binary they expire at exactly 0 or 100. But buried inside Black-Scholes is something Polymarket traders almost never use: implied volatility.
Implied volatility is the market's consensus estimate of how much an underlying will move before expiration. When Black-Scholes is inverted when you plug in a price and solve for volatility you get the market's implied expectation of uncertainty.
On Polymarket, this reveals something powerful: where the market is pricing uncertainty incorrectly.
The Adaptation:
For binary contracts (like Polymarket), the Black-Scholes digital option formula is:
Price = e^(-rT) × N(d2)
Where:
d2 = [ln(S/K) + (r - σ²/2)T] / (σ√T)
N() = cumulative normal distribution
S = current "probability" (contract price)
K = strike probability (typically 0.50)
r = risk-free rate (near 0 for short-duration markets)
T = time to expiration (in years)
σ = implied volatility
```python
import numpy as np
from scipy.stats import norm
from scipy.optimize import brentq
def binary_black_scholes_price(S, K, T, r, sigma):
"""
Price a binary option (pays 1 if S > K at expiry).
S: current probability estimate
K: threshold (usually 0.5)
T: time to expiry in years
r: risk-free rate (use 0 for simplicity)
sigma: volatility of probability path
"""
if T <= 0:
return 1.0 if S > K else 0.0
d2 = (np.log(S/K) + (r - 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
price = np.exp(-r * T) * norm.cdf(d2)
return price
def implied_volatility(market_price, S, K, T, r=0):
"""
Solve for implied volatility given a market price.
This reveals what volatility the market is 'pricing in'.
"""
def objective(sigma):
return binary_black_scholes_price(S, K, T, r, sigma) - market_price
try:
iv = brentq(objective, 0.01, 10.0)
return iv
except ValueError:
return None
# Example: Election market
# Contract at 55¢, 30 days to election, currently estimated 55% chance
market_price = 0.55
current_prob = 0.55
days_to_expiry = 30
T = days_to_expiry / 365
iv = implied_volatility(market_price, current_prob, K=0.5, T=T)
print(f"Implied Volatility: {iv:.1%}")
# Now compare to a different market with same price but longer duration
T_long = 90 / 365
iv_long = implied_volatility(market_price, current_prob, K=0.5, T=T_long)
print(f"IV (90-day market): {iv_long:.1%}")
# If implied vol is LOW relative to historical vol → market is underpricing risk
# If implied vol is HIGH relative to historical vol → market is overpricing certainty
```The Real Edge: Vol Surface Arbitrage
Here's where it gets interesting. The same event often trades across multiple timeframes on Polymarket: "Will X happen by March?" and "Will X happen by June?" and "Will X happen in 2026?"
Black-Scholes tells you what the relationship between these prices should be. When it breaks down when the 3-month contract is "cheaper" than the Black-Scholes model predicts relative to the 6-month that's exploitable.
```python
def find_vol_surface_edge(contracts):
"""
Given multiple contracts on same event at different timeframes,
find where implied volatility is inconsistent.
contracts: list of (price, days_to_expiry) tuples
"""
vols = []
for price, days in contracts:
T = days / 365
iv = implied_volatility(price, price, K=0.5, T=T)
vols.append((days, price, iv))
avg_iv = np.mean([v[2] for v in vols if v[2] is not None])
edges = []
for days, price, iv in vols:
if iv is None:
continue
edge = iv - avg_iv
fair_price = binary_black_scholes_price(
price, 0.5, days/365, 0, avg_iv
)
edges.append({
"days": days,
"market_price": price,
"implied_vol": iv,
"fair_price": fair_price,
"edge_cents": (fair_price - price) * 100
})
return sorted(edges, key=lambda x: abs(x["edge_cents"]), reverse=True)
# Example: Three markets on same political event
contracts = [
(0.42, 14), # 14 days out — short-term market
(0.45, 45), # 45 days out
(0.51, 90), # 90 days out — long-term market
]
edges = find_vol_surface_edge(contracts)
for e in edges:
print(f"{e['days']}d: Market {e['market_price']:.0%} | "
f"Fair {e['fair_price']:.0%} | "
f"Edge {e['edge_cents']:+.1f}¢ | "
f"IV {e['implied_vol']:.0%}")
```The System: Running All Three Together
These formulas don't compete. They stack.
Here's the complete pipeline:
Step 1: Bayes Establish your probability estimate Use news, data, and priors to calculate what you think the true probability is.
Step 2: Black-Scholes Verify the market isn't pricing risk correctly Check if the market's implied volatility is consistent with what you'd expect.
Step 3: Kelly Size the position correctly Never bet more than Kelly says, regardless of how confident you feel.
```python
def complete_trading_system(
prior_probability,
market_price_cents,
days_to_expiry,
bankroll,
news_events=None # list of (p_evidence_given_yes, p_evidence_given_no) tuples
):
"""
Complete 3-formula trading system.
Returns: trade decision with full reasoning
"""
# STEP 1: BAYES — Update probability with any news
current_prob = prior_probability
if news_events:
for (p_yes, p_no) in news_events:
current_prob = bayes_update(current_prob, p_yes, p_no)
# STEP 2: BLACK-SCHOLES — Check implied vol
market_price = market_price_cents / 100
T = days_to_expiry / 365
iv = implied_volatility(market_price, current_prob, K=0.5, T=T)
fair_price = binary_black_scholes_price(current_prob, 0.5, T, 0, iv or 0.5)
# STEP 3: KELLY — Size the position
f = kelly_fraction(current_prob, market_price_cents)
f_quarter = f * 0.25
position_size = bankroll * f_quarter
edge_cents = (current_prob - market_price) * 100
return {
"prior_prob": prior_probability,
"bayesian_prob": current_prob,
"market_price": market_price,
"fair_price_bs": fair_price,
"edge_cents": edge_cents,
"implied_vol": iv,
"kelly_fraction": f,
"quarter_kelly_fraction": f_quarter,
"position_size_usd": position_size,
"trade": "BUY YES" if current_prob > market_price else "BUY NO" if market_price > current_prob + 0.03 else "PASS"
}
# Full example: 2026 election market
result = complete_trading_system(
prior_probability=0.55, # You think 55% chance of YES
market_price_cents=42, # Market says 42¢
days_to_expiry=45,
bankroll=10000,
news_events=[
(0.30, 0.70), # Unfavorable poll for YES candidate
(0.85, 0.40), # Strong fundraising report for YES candidate
]
)
print("=" * 50)
print("TRADE ANALYSIS")
print("=" * 50)
for k, v in result.items():
if isinstance(v, float):
print(f"{k:30s}: {v:.3f}")
else:
print(f"{k:30s}: {v}")
```What the Data Actually Says
Jonathan Becker's 2026 analysis of 72.1 million Polymarket trades found something that confirms exactly what these three formulas predict:
Traders who place limit orders (Bayesian, calculated) earn +1.12% per trade. Traders who place market orders (emotional, reactive) lose -1.12% per trade.
The 2.24 percentage point gap is statistically bulletproof across the entire dataset.
Bayes gives you the edge. Black-Scholes confirms where the market is wrong. Kelly tells you how much to bet.
Three formulas. 263 years of mathematics. One Polymarket account.
The priest, the telephone engineer, and the two economists who nearly broke Wall Street none of them knew they were building tools for a prediction market that wouldn't exist for another 200 years.
But the math was always waiting.