Logarithmic Market Scoring Rule (LMSR)
Robin Hanson's logarithmic market scoring rule is the most widely used prediction-market maker. It takes the logarithmic scoring rule, the prototypical strictly proper rule for eliciting a single forecaster's belief, and turns it into a sequential market that any number of traders can update, always quoting a live probability and standing ready to fill any trade at a mechanically computed price. The result has a closed-form cost function, a hard bound on what the operator can lose, and sits as the entropic special case of the general cost-function maker.
From the log score to a sequential market maker
A proper scoring rule pays a forecaster $S(\mathbf{p}, i)$ when they report distribution $\mathbf{p}$ and outcome $i$ is realised; the logarithmic rule $S(\mathbf{p}, i) = b\log p_i$ makes truthful reporting uniquely optimal. Hanson's market scoring rule idea (2003) chains these payments together: the rule's current report is the market's standing estimate, and a trader who wishes to move it from $\mathbf{p}$ to $\mathbf{p}'$ must pay off the previous forecaster's score and is in turn paid off by the next. Each trader is rewarded exactly for the information they add, and the institution backstopping the chain acts as a forecaster of last resort, so the market always has a price, even with one participant. This is what makes the mechanism especially suited to combinatorial markets, where an ordinary order book would be impossibly thin across exponentially many states.
The cost function and prices
Re-expressed over outstanding share quantities $q = (q_1,\dots,q_n)$, where each share of outcome $i$ pays \$1 if $i$ occurs, the chained scoring rule collapses into a single convex potential, the cost function:
A trader who moves the share vector from $q$ to $q'$ simply pays the difference $C(q') - C(q)$; there is no order matching at all. The instantaneous (marginal) prices are the gradient $\nabla C$, which is exactly the softmax of the scaled holdings:
These prices are non-negative and sum to one, so they read directly as the
market's implied probabilities. In code, LMSR.cost(q) evaluates
$C$ with a numerically stable log-sum-exp, LMSR.prices(q) returns
the softmax, and LMSR.buy(outcome, shares) charges
cost_to_trade $= C(q') - C(q)$ before applying the trade.
Bounded worst-case loss
The defining virtue of LMSR is that the operator's exposure is capped no matter how the market moves. Starting from a uniform book $q = 0$ and paying out $q_w$ on the winning outcome $w$, the worst-case loss over every trading path and every final state is
This is exposed as the LMSR.max_loss property, while
realized_pnl(winner) returns the operator's actual outcome,
revenue $C(q) - C(0)$ collected from traders minus the payout $q_w$, which is
bounded below by $-b\log n$. That bounded subsidy is not a flaw but the
price of the information: it is the fixed budget a sponsor pays to
stand up a liquid market and have traders aggregate their beliefs into a
probability. A market that can never lose more than $b\log n$ is one whose
cost of running is known in advance.
The liquidity parameter $b$
The single tuning knob $b \gt 0$ governs the depth-versus-subsidy trade-off.
It scales how many shares must be bought to move the price a given amount: a
large $b$ yields a deep, low-impact market that absorbs big
trades with little price movement, at the cost of a larger potential subsidy
$b\log n$; a small $b$ yields a thin, responsive market that
jumps on small trades but risks little. Because $b$ multiplies the worst-case
loss linearly while only entering the prices through the ratio $q_i/b$,
choosing it is precisely choosing how much the sponsor is willing to spend to
buy liquidity. The constructor defaults to b = 100.0.
Liquidity-sensitive LMSR (Othman–Sandholm)
Plain LMSR fixes $b$ up front and runs at a guaranteed expected loss; it is a subsidised device. Othman, Pennock, Reeves & Sandholm (2010/2013) make liquidity respond to activity by replacing the constant with a volume-dependent
so the market deepens as more shares are outstanding. The maker then earns a positive bid–ask spread and can run at a profit rather than a fixed loss. The trade-off is that prices no longer normalise exactly to one; they sum to a little over unity, a small over-round that is precisely the spread the operator collects. Othman & Sandholm (2011) ground this construction in the theory of homogeneous (coherent) risk measures, and the same family powered the large-scale Gates Hillman Prediction Market deployment.
Relation to the general cost-function maker
LMSR is one point in a much larger design space. Abernethy, Chen & Wortman Vaughan (2013) showed that any convex potential $C$ defines a valid cost-function market maker: prices are $\nabla C$, convexity of $C$ is exactly no-arbitrage, and a bounded range of the conjugate regulariser $R = C^\ast$ on the simplex is exactly bounded loss. LMSR is the special case where $C$ is the scaled log-partition function and the implicit regulariser is negative entropy, the entropic, maximally-symmetric choice. Viewed through convex duality this is the same object as the constant-function market makers of DeFi: a prediction-market maker is a convex potential $C(q)$ priced by its gradient, a CFMM is a concave trading function priced by the ratio of its partials, and up to a change of variables they are two faces of convex-potential market making, one emphasising bounded-loss elicitation, the other fees and capital efficiency.
Watch the market aggregate information
A hidden true probability $p^\star$ sits behind the question. Traders arrive one at a time, each with a noisy private signal, and move the LMSR price toward their belief. Watch the price discover $p^\star$ as scattered private information is pooled into one number, the price-discovery story behind market scoring rules. Drag $p^\star$ or the signal noise and watch it re-converge.
Try it: buy shares directly
A two-outcome LMSR. Drag to buy shares of outcome A; watch the prices (implied probabilities) move and the cost accrue. The market maker's loss is bounded by $b\log n$.
Code: mechanisms/lmsr.py · Demo: examples/sim_lmsr.py · Related: cost-function makers, scoring rules, CFMMs · Research: market-scoring-rules-and-amms.md