Full Kelly vs Fractional Kelly in Python

This page builds on Kelly Criterion in Python: Calculate a Bankroll Fraction with Keeks, which covers the full Kelly formula, its inputs, and its clamps in detail. Read that page first if you have not already.

Quick answer

Fractional Kelly multiplies the full-Kelly fraction by a selected value between zero and one. Keeks does the scaling; you supply the fraction and the probability estimate.

Full Kelly versus fractional Kelly

Question	Full Kelly	Fractional Kelly
What Keeks calculates	The model’s full repeated-bet fraction	fraction × the full-Kelly result
Extra user input	None	A number from 0 through 1
Same payoff/loss/cost inputs?	Yes	Yes
Does the result predict profit?	No	No
Can it price a one-time gamble?	Separate method	Separate method; do not mix it into this comparison

Smaller stake sizes change the strategy’s exposure to variance. They do not change, and cannot express, anything about whether the underlying probability estimate is correct.

Python comparison with identical inputs

Both classes take the same payoff, loss, and transaction_cost_rate inputs and share the same evaluate() method:

from keeks.binary_strategies import (
    FractionalKellyCriterion,
    KellyCriterion,
)

inputs = {
    "payoff": 1.0,
    "loss": 1.0,
    "transaction_cost_rate": 0.01,
}
bankroll = 1_000.0
probability = 0.55

full = KellyCriterion(**inputs)
half = FractionalKellyCriterion(**inputs, fraction=0.5)
quarter = FractionalKellyCriterion(**inputs, fraction=0.25)

for label, strategy in [
    ("Full Kelly", full),
    ("Half Kelly", half),
    ("Quarter Kelly", quarter),
]:
    fraction = strategy.evaluate(probability, bankroll)
    print(f"{label}: {fraction:.4%} (${bankroll * fraction:.2f})")

Full Kelly: 9.0009% ($90.01)
Half Kelly: 4.5005% ($45.00)
Quarter Kelly: 2.2502% ($22.50)

The values demonstrate scaling, not realized returns. Fractional Kelly computes the full-Kelly fraction first — floor and maximum-safe-bet clamp included — and only then multiplies by the selected fraction. See Kelly Criterion in Python: Calculate a Bankroll Fraction with Keeks for what those clamps do.

Half Kelly and quarter Kelly

fraction=0.5 (“half Kelly”) and fraction=0.25 (“quarter Kelly”) are just FractionalKellyCriterion constructor arguments — there is no separate class for them. Lower fractions reduce both the size of individual stakes and the variance of the resulting bankroll path; they do not change whether the strategy is right about the win probability.

What Keeks does and does not decide

FractionalKellyCriterion performs the scaling arithmetic and applies the same safety floor and clamp as full Kelly. It does not decide which fraction to use, and it does not validate your probability estimate. Those are choices you make going in.

How to compare strategies in a simulation

A fair comparison between strategies needs:

• a fresh bankroll and a fresh strategy object per run — simulators mutate the bankroll in place, and some strategies carry state across evaluate() calls;

• identical simulator inputs (payoff, loss, fee_per_bet, probability) across every strategy being compared;

• multiple seeded runs, because a single stochastic path does not support a general claim about which strategy is “better”; and

• a distribution of terminal outcomes, not one number, since the mean of a Kelly-like strategy’s terminal bankroll is often dominated by a handful of extreme paths.

Keeks ships a seeded, reproducible benchmark that runs all nine strategies under identical assumptions and reports exactly this kind of distribution — median and percentile terminal bankroll, drawdown, growth rate, and early-stop rates. See Nine-Strategy Risk Benchmark for the current figures; this page does not restate them, so there is only one place they can go stale.

Repeated sizing is not one-time pricing

Both classes on this page answer a repeated-bet question. A different question — the maximum price to pay for a single, one-time gamble with known outcomes and probabilities — is answered by Utilities’s find_indifference_price() instead. Keep the two separate.

Next step

Run the comparison code above with your own probability and fraction, then see Kelly Criterion in Python: Calculate a Bankroll Fraction with Keeks for the full-Kelly formula and clamp details, or Nine-Strategy Risk Benchmark for how all nine strategies behave under identical, seeded assumptions.