← Home

Implementations

A small Python library, mirrored by parity-tested JavaScript ports.

Every mechanism has a Python reference implementation in the mechanisms package, dependency-light (numpy only) and written to be read. The core deterministic mechanisms additionally have JavaScript ports that power the browser demos and are checked for numerical parity against Python in the test suite.

Python package

pip install -e ".[test]"

JavaScript ports, tested against Python

The browser demos must not quietly drift from the library, so the JavaScript in docs/js/mechanisms.js is a faithful port of the Python reference and is verified against it: tests/test_js_parity.py runs each JS function in a Node subprocess (via tests/js_parity_runner.js) and asserts the result equals the Python implementation to floating-point tolerance. The parity tests skip cleanly if node is not installed, so Python-only CI is unaffected. (Pattern borrowed from microprediction/humpday, where JS optimizers are validated against their Python counterparts.)

# Python reference, JS port, and the parity check
pytest -q                          # full suite (Python + JS parity)
node tests/js_parity_runner.js lmsrPrices '[[10,-5,3],50]'

Run the tour

python examples/quickstart.py

Example simulations

Each demo in examples/ drives one mechanism through a short Monte-Carlo story and prints the result as a terminal chart (numpy-only, no plotting dependencies), so they run anywhere.

• sim_scoring_rules.py, truthful reporting beats a confident misreport under the log, Brier & spherical rules: what strictly proper means.
• sim_lmsr.py, informed traders move an LMSR market to the true probability while the maker's loss stays under b·log n.
• sim_parimutuel.py, a pool aggregates noisy private beliefs, then reproduces the favourite–longshot bias.
• sim_cda.py, zero-intelligence traders drive a continuous double auction to competitive equilibrium (Gode & Sunder, 1993).
• sim_amm.py, a constant-product LP's fees raced against impermanent loss under a random-walk price.
• sim_perp.py, the funding rate tethers a perpetual to its index; a 5× leveraged long gets liquidated.
• sim_pm_amm.py, the pm-AMM prices a binary market as the Gaussian CDF Φ((y−x)/L): always a probability, outcomes summing to 1.
• sim_fba.py, a frequent batch auction clears everyone at one uniform price at the equilibrium volume (Budish, Cramton & Shim, 2015).
• sim_peer_prediction.py, the Bayesian Truth Serum out-scores a strategist with no ground truth (Prelec, 2004).
• sim_aggregation.py, linear vs logarithmic vs depth-trimmed opinion pools under confidently-wrong nodes, trimming wins.
• sim_cmm.py, one convex potential subsumes LMSR (and a quadratic maker); the finite-difference price fallback matches the analytic gradient.
• sim_calibration.py, diagnose an overconfident forecaster (reliability diagram, ECE, Brier decomposition) and fix it with temperature recalibration.
• sim_pipeline.py, composing two mechanisms: an elicitation market produces a forecast, a calibration critic PITs it for uniformity, and wealth flows to the calibrated reports until the critic's edge collapses.
• sim_local_scoring.py, rank unnormalised models with the Hyvärinen score (no partition function) and confirm invariance to the normalizing constant.
• sim_correlated_agreement.py, Correlated Agreement elicits truth with no ground truth, defeats the constant-report exploit, and is stochastic-dominance (enforced) truthful.
• sim_combinatorial.py, a combinatorial LMSR learns a dependence: buying A&B lifts P(A|B) above P(A) while Bayes consistency holds.
• sim_hybrid_market.py, hybrid CLOB+AMM: complementary resting orders fill a large buy at near-zero slippage where the AMM alone would move the price hard.

python examples/sim_lmsr.py