Stake, audits, bribes and disputes: the equilibrium economics of refereed and optimistic verification.
19 projects, each with its own page, code and tests. See them on the full research index.
Inspection-game economics of refereed verification: stake substitutes for re-execution, extra verifiers free-ride, and optimal tolerance/stake under floating-point drift.
Inspection-game equilibrium for optimistic verification: stake substitutes for re-execution, extra verifiers dilute rewards (free-riding saturates), and joint tolerance/stake design under floating-point drift. Stylised model.
Bribing verifiers in refereed verification: closed-form bribe floor, a sharp collusion-proof stake that falls as 1/m, and jackpots that raise the floor one-for-one.
Closed-form bribe floor for buying verifier silence in refereed verification: a sharp collusion-proof stake (falls as 1/m verifiers), and planted-fault jackpots that lift the floor. Verified against brute force and Monte Carlo. Stylised model.
No-regret learning in the refereed-verification inspection game: conserved potential, closed-form cycle period, averages converge but per-round audit probability collapses; optimistic Hedge converges.
Hedge dynamics in the inspection game: a conserved potential, a closed-form cycle period (matched to simulation within 0.1%), time-averages that converge while per-round audit probability collapses, and optimistic Hedge that converges last-iterate. Stylised.
M verifiers in the inspection game: detection pinned at s/(s+S), cheating rises with m under split rewards, symmetric equilibrium is a saddle (volunteer's dilemma), bandit learners need an exploration floor.
Closed-form m-verifier audit equilibrium (detection pinned at s/(s+S), redundancy bounded by ln(1/(1-q))/q, cheating rising with m under split rewards), a saddle-point stability result, Hedge dynamics that concentrate audit burden on a subset, and bandit learners that need an exploration floor. Stylised.
Sampled audits of committed training traces: payoff is convex in corrupted steps, deterrence iff min(F, f·k) ≥ T·g, so stake and audits are complements and stake must scale with job length.
Sampled audits of a committed training trace under capped slashing: cheating payoff is convex in the number of corrupted steps, and deterrence holds iff min(F, f·k) ≥ T·g. Stake and audits are complements, so stake must scale with job length. Exact hypergeometric computation. Stylised.
Random k-fold replication with slashing against a colluding fraction β: secret assignment makes cheating a coordination game with unique-honesty stake Gβ^{k−1}/(1−β^{k−1}), public assignment leaves β^k corruption at any stake, and assignment leaks leave a λβ^k floor.
Random k-fold replication with slashing against a colluding fraction β of workers: with secret assignment cheating is a coordination game and honesty is the unique equilibrium iff S ≥ Gβk−1/(1−βk−1), geometric in k; with public assignment colluders cheat only on all-friend jobs, so corruption is βk at any stake; a leak probability λ leaves a λβk floor, so each order of magnitude of leakage costs about two replicas. Formulas match Monte Carlo. Stylised.
Scarce audit budget across heterogeneous jobs: deterrence threshold g/(g+S) makes it a knapsack, greedy with a 1/3 guarantee (within 1% on 91% of instances), uniform audits need up to 1.9× the budget, heterogeneity lowers deterrence cost (Jensen), stake substitutes for audits.
Refereed verification with jobs of different gain and harm: a best-responding cheater is deterred iff the audit probability reaches g/(g+S), so allocation is a knapsack (deter a set exactly, spend the rest on one job). Density greedy with a partial-only candidate has a proved 1/3 guarantee and is within 1% of optimal on 91% of random instances; uniform auditing needs up to 1.9× the budget to deter everything and still leaves 26% of harm at that budget; gain heterogeneity lowers deterrence cost (Jensen); stake substitutes for audits via Σ g/(g+S) = B. Stylised.
Staffing the audit pool that stake-based deterrence needs: exact Erlang-C waiting (matches simulation), square-root staffing R+1.06√R (spare capacity 60% at R=5, 1.1% at 10⁴), stake–headcount optimum G+S=√(wsG/(rd₀)) (cost 24 vs 77 at too little stake), and bursty audit demand delays 1.8× what Allen–Cunneen predicts.
Stake sets the audit rate a = G/(G+S); the audits then form a queue with offered load R = λas. Erlang-C waiting matches simulation (P(wait) 0.409 vs 0.407), and square-root staffing c = R + 1.06√R is within 1.5 servers of the exact minimum for R ≥ 100, so the spare capacity needed falls from 60% at R=5 to 1.1% at 104. Stake and headcount trade off with first-order optimum G+S = √(ws G/(rd0)): total cost 23.6 at the optimum versus 76.8 with too little stake and 65 with too much. Heavy-tailed audit times make Allen–Cunneen pessimistic (0.97 vs 0.63); batches of simultaneous audits make it optimistic (0.82 vs 1.45 at batch size 4). Stylised costs, FIFO, static outages.
Escalating-bond dispute games: exact deterrence opening bond εV/((1−ε)C−εD) shrinks geometrically in rounds while the attacker's total outlay barely moves, and a sharp capital race where the defender needs γ·max{C(r) ≤ B_C} ≤ γ·B_C.
Bond-escalation dispute games with a fallible oracle, solved exactly: the opening bond that deters false challenges is εV/((1−ε)C−εD) and shrinks geometrically in rounds (20.4 to 10−5) while the attacker's total outlay barely moves (20.41 to 20.62); against a capital-limited attacker the honest defender needs exactly γ·max{C(r)≤BC} ≤ γBC, so the responder pays γ per exchange. Stylised.
K-ary bisection dispute games: optimal arity solves k ln k − k + 1 = a/b (binary only if a/b ≤ 0.386), 1.9–6× cheaper than binary at T=10⁶, adaptive schedules gain ≤1%, leaf-size trade-off, latency as extra round cost.
Arity and leaf size of k-ary bisection dispute games for refereed verification: the optimal arity solves k ln k − k + 1 = a/b (binary only if a/b ≤ 2ln2−1), arity 10 is 1.9× cheaper than binary at a million steps and 6× at a/b=1000, exact adaptive schedules gain at most about 1%, early-stopping with referee re-execution saves 9–56%, and latency just widens arity. Verified on an executable SHA-256 dispute. Stylised.
Optimistic-verification challenge windows with bribable proposers: exact gamble-then-bribe attacker recursion, closed-form window, stake cannot shorten it under an exogenous bribe price (63 blocks for S=10…1600), bounty-funded priority fees give S·w ≈ G/((1−ρ)θ).
In optimistic verification a fraud pays G unless a challenge is included within w blocks; the attacker controls each proposer w.p. ρ and otherwise pays b to censor. The exact attacker recursion V(n) = ρV(n−1) + (1−ρ)max(−S, V(n−1)−b) gives a closed-form deterrence window (0 mismatches in 5000 instances; Monte Carlo agrees) with a gamble-first, bribe-last optimal attack. A luck-only analysis underestimates the window 100–170×; with an exogenous bribe price the window is 63 blocks for every stake from 10 to 1600; if the bounty is paid as a priority fee the price becomes θS and S·w ≈ G/((1−ρ)θ). Stylised.
Escalating jury appeal ladders with fee-priced appeals: an exact fee window makes error ∏(1−M_k), 11 jurors is the smallest deterring panel at prize 100, 3→11→27 errs 2.4e-4 at 5.8 expected seats vs 12.6% for one 7-seat panel, shared jury bias sets a floor ρ(1−a).
Proper scoring rules, Peer Truth Serum, Correlated Agreement and LMSR aggregation, with eight follow-ups on mechanism-aware adversaries (trust farming, whitewashing, closed-loop attackers) and defences. Pure-Python, dependency-free, 72 tests.
Cost-function markets as online learners for modular, continual-learning expert routing: verified equivalence and loss/regret bounds, and a switching-environment simulation where the quadratic market stays sparse and low-regret at liquidity levels where LMSR degrades. Small-scale; limitations stated.
Weighted-score wagering (Lambert et al.) as a budget-balanced, replayable mixture-of-experts gate under recurring regime drift: plain wagering locks in, fixed-share wealth tax repairs it but subsidises free-riders. Pure-Python, 13 tests.
Quantile, expectile and Bregman scoring rules, a check that variance is not elicitable alone but is jointly, and a study of pricing benign-drift thresholds for replica verification. Pure-Python, 6 tests.
Inspection-game equilibrium for optimistic verification: stake substitutes for re-execution, extra verifiers dilute rewards (free-riding saturates), and joint tolerance/stake design under floating-point drift. Pure-Python, 7 tests, stylised model.
Closed-form bribe floor for buying verifier silence in refereed verification: a sharp collusion-proof stake (falls as 1/m verifiers), and planted-fault jackpots that lift the floor. Verified against brute force and Monte Carlo. Pure-Python, 7 tests, stylised model.
Measured float32 drift across reduction orders (relative drift is Cauchy-tailed, state-level drift is a few ulps), a Merkle-committed training trace with a teacher-forced referee, and the finding that a per-step tolerance is a cumulative hidden-deviation budget while bitwise-reproducible operators remove it. Pure-Python, 10 tests.
Differentially private LMSR via the binary-tree mechanism: error scales as 1/(bε), tree noise beats per-release noise ~15×, and privacy noise is exploitable so market-maker loss far exceeds b ln 2. Pure-Python, 6 tests, stylised.
Hedge dynamics in the inspection game: a conserved potential, a closed-form cycle period (matched to simulation within 0.1%), time-averages that converge while per-round audit probability collapses, and optimistic Hedge that converges last-iterate. Pure-Python, 8 tests, stylised.
Closed-form m-verifier audit equilibrium (detection pinned at s/(s+S), redundancy bounded by ln(1/(1-q))/q, cheating rising with m under split rewards), a saddle-point stability result, Hedge dynamics that concentrate audit burden on a subset, and bandit learners that need an exploration floor. Pure-Python, 10 tests, stylised.
A model-improvement market paying holdout-loss decreases: the budget telescopes, but naive payment feedback lets a data-less adversary be paid while the published model's true loss worsens; a Ladder-style threshold removes the attack at a measured cost to honest small contributors. Pure-Python, 4 tests, stylised.
Sampled audits of a committed training trace under capped slashing: cheating payoff is convex in the number of corrupted steps, and deterrence holds iff min(F, f·k) ≥ T·g. Stake and audits are complements, so stake must scale with job length. Exact hypergeometric computation, 7 tests, stylised.
Regret of reporting from a finite grid under Brier and log scores: a high-resolution law for the optimal grid (matched to 0.3%), a ln N loss for uniform grids under log score, and a 13× penalty for raw minifloat formats versus symmetrised ones. Pure-Python, 7 tests, stylised.
Effort elicitation with proper scoring rules in an exact beta-binomial model: implementable efforts are the concave envelope of the value curve, Brier information rent is exactly (n−1)/(a+b) times effort cost, and the log score needs half Brier's payout spread on rare-fault priors. Pure-Python, 6 tests, stylised.
Pooling calibrated experts with shared training data: the Bayes-optimal logit exponent a* = n/(1+(n−1)ρ) (matched to a numerical argmin), extra experts saturating at 1/ρ effective experts, naive independence pooling doing worse than chance at ρ=0.9, and an online learner that finds a*. Pure-Python, 6 tests, stylised.
Scoring-rule payments as moral-hazard contracts for costly inference: a closed-form shirking threshold (matched to 1%), first-best effort at scale equal to marginal value with a fee, and under limited liability only 48–65% of first-best surplus, with log score cheaper than Brier at high effort. Pure-Python, 6 tests, stylised.
Peer prediction for unverifiable labelling and judging work: output agreement pays 1.0 for always answering the majority label versus 0.68 for honesty, the Dasgupta–Ghosh payoff is exactly 2p(1−p)gigj, effort becomes a coordination game with a closed-form threshold (12.8× higher for rare-positive tasks), and a cost-optimal gold-check rate √(c·gH/G) removes the shirking equilibrium. Pure-Python, 8 tests, stylised.
Exact calibration functions turning a proper-score gap into a certified cap on accept/audit/slash regret: Brier transfers as ε², log as a KL, polyhedral hinge linearly but without proper elicitation, and an audit action tightens the guarantee; the certificate is never violated in simulation and is attained by a two-point verifier. Pure-Python, 7 tests, stylised.
Reject-option surrogates for accept/reject/escalate decisions: the generalised-hinge conditional risk embeds the Bayes action at its kinks, regret transfers linearly with constant exactly 2d (grid-verified), logistic transfer degrades as 2d(1−d)/δ, and a negative result shows logistic-plus-thresholds still learns faster in scalar SGD. Pure-Python, 6 tests, stylised.
Sybil splitting and whale merging under stake-weighted pools: only linear-in-stake weights are split-invariant, per-head pools are captured at k* = √(Rn/c) − n identities (exact match), a sharp per-identity deterrence fee, exponents above 1 reward merging, and weighted-score wagering is split-neutral. Pure-Python, 7 tests, stylised.
Mean, median and trimmed-mean aggregation of verifier reports under a Byzantine fraction β: mean bias βB is unbounded, median bias σΦ−1(1/(2(1−β))) is independent of B and diverges at β=½, trimmed-mean closed form for τ≥β matches simulation, and trimming below β fails. Pure-Python, 7 tests, stylised.
Anytime-valid slashing of miscalibrated verifiers with e-processes: repeatedly re-running a z-test falsely slashes 37% of honest verifiers at nominal 5%, the likelihood-ratio e-process stays under α by Ville’s inequality, detection delay tracks ln(1/α)/KL within 12% (logarithmic in 1/α), and not knowing the cheating rate costs a factor 1.36. Pure-Python, 6 tests, stylised.
Pairwise gossip averaging as a stand-in for all-reduce: disagreement contracts by exactly (n−2)/(2(n−1)) ≈ ½ per matching round (about 20 rounds at any n), the noise floor is (n−1)(n−2)s²/n (matched to 0.3%), a single stubborn node captures the honest mean at exact rate 1−1/(n(n−1)), and a trust-region clip turns capture into linear creep of at most τ/(n(n−1)) per step. Pure-Python, 7 tests, stylised.
Exact value of verifier committees for an accept/slash decision: value is zero below a closed-form minimum committee size (4 at π=0.05, q=0.7) even though mutual information is submodular, 24–34% of triples violate diminishing returns, myopic marginal-value hiring buys nothing (ratio 0 to the optimum) and leave-one-out pay is a parity sawtooth that falls 7× below average value at 40 verifiers. Pure-Python, 8 tests, stylised.
Arity and leaf size of k-ary bisection dispute games for refereed verification: the optimal arity solves k ln k − k + 1 = a/b (binary only if a/b ≤ 2ln2−1), arity 10 is 1.9× cheaper than binary at a million steps and 6× at a/b=1000, exact adaptive schedules gain at most about 1%, early-stopping with referee re-execution saves 9–56%, and latency just widens arity. Verified on an executable SHA-256 dispute. Pure-Python, 10 tests, stylised.
Reverse auction for k compute units from n devices with private costs: the truthful threshold auction pays exactly k(k+1)/(n+1), twice the winners’ true cost for every n and k (also with a reserve), the buyer-optimal reserve is exactly v/2 (worth up to +1.03 utility in thin markets, nothing once v≥2), and the pay-as-bid equilibrium has closed form and matches revenue (1.3334 vs 1.3333). Pure-Python, 9 tests, stylised.
Hedge/LMSR routing of modular experts when losses arrive after device-dependent delays: regret ≤ ln N/η + ηT/8 + ηD/2 with D the total outstanding rounds, so mean delay d̄ inflates the horizon by 1+4d̄; ignoring delay costs 12× regret against a reactive adversary at delay 100, the worst-case tuned rate is too cautious on oblivious data, an observable-count adaptive rate recovers most of it, and LMSR subsidy grows about 20× at mean delay 5. Pure-Python, 11 tests, stylised.
Random k-fold replication with slashing against a colluding fraction β of workers: with secret assignment cheating is a coordination game and honesty is the unique equilibrium iff S ≥ Gβk−1/(1−βk−1), geometric in k; with public assignment colluders cheat only on all-friend jobs, so corruption is βk at any stake; a leak probability λ leaves a λβk floor, so each order of magnitude of leakage costs about two replicas. Formulas match Monte Carlo. Pure-Python, 11 tests, stylised.
An uninformed manipulator pushing an LMSR verification market from q to τ loses exactly b·KL(q‖τ), which equals to the digit the extra rent it hands to informed traders; the accuracy change is μ[e1(1−q) − e0q − (1−2q)], positive only in a liquidity band (0.107, 0.413 in the baseline): below it nobody enters and manipulation costs 1−2q accuracy, above b = Nc/(H(q)−ln(1/(1−ε))) entry is certain and manipulation is neutral. Matches an executable LMSR Monte Carlo. Pure-Python, 9 tests, stylised.
Refereed verification with jobs of different gain and harm: a best-responding cheater is deterred iff the audit probability reaches g/(g+S), so allocation is a knapsack (deter a set exactly, spend the rest on one job). Density greedy with a partial-only candidate has a proved 1/3 guarantee and is within 1% of optimal on 91% of random instances; uniform auditing needs up to 1.9× the budget to deter everything and still leaves 26% of harm at that budget; gain heterogeneity lowers deterrence cost (Jensen); stake substitutes for audits via Σ g/(g+S) = B. Pure-Python, 10 tests, stylised.
Exact checkpoint interval under Poisson churn: w* = (1+W0(−e−1−λC))/λ, independent of restart cost, with Young/Daly overshooting by 5–25%; intervals within 2× cost under 3.5%; a synchronous job on n workers restarts at rate nλ so efficiency falls to 50% near n≈700, and admitting flaky workers cut throughput five-fold. Pure-Python, 8 tests, stylised.
Paying contributors of data or gradients by Shapley value rewards replication even when copies add zero information: in a Bayesian mean-estimation game the replicator's payment rises with every copy to its stand-alone value, exactly (n+2)/2 times the honest payment against n unit-precision others (5.5× at n=9). If the evaluator treats copies as independent the replicator's pot share tends to 100%; leave-one-out pays true copies exactly zero but distributes only 1/(n+1) of the pot; collapsing duplicates fixes it but underpays independent look-alikes by 45%. Exact computation checked against permutation brute force. Pure-Python, 9 tests, stylised.
Bond-escalation dispute games with a fallible oracle, solved exactly: the opening bond that deters false challenges is εV/((1−ε)C−εD) and shrinks geometrically in rounds (20.4 to 10−5) while the attacker's total outlay barely moves (20.41 to 20.62); against a capital-limited attacker the honest defender needs exactly γ·max{C(r)≤BC} ≤ γBC, so the responder pays γ per exchange. Pure-Python, 9 tests, stylised.
Local-SGD / DiLoCo-style averaging of heterogeneous quadratic workers has a closed-form fixed point: a weighted mean of the workers' optima with weights 1−(1−ηai)H that saturate, so it is exactly unbiased at H=1, forgets curvature as H grows (converging to the unweighted mean), and is non-monotone in between. Weighting by ai/wi removes the bias exactly; if the server trusts claimed step counts, a low-curvature worker moves the fixed point from 0.50 to 0.91 by claiming 100 steps instead of 5, tying communication savings to verified work. Wall-clock-optimal H under a bias tolerance is 5.7× faster than H=1 at moderate comm cost, with a non-interval feasible set. Noise formulas match Monte Carlo. Pure-Python, 8 tests, stylised.
A decentralised inference provider substitutes a cheaper model on a random fraction p of queries; a verifier re-scores a fraction f under an anytime-valid mixture e-process. Detection delay scales as 1/(f p² χ²), so the profitable attack is a slow leak: undetected savings grow as √N rather than N (measured ×7.75 for ×64 queries). Closed-form audit rate to cap theft, cost-optimal check rate (hK/2Nc)2/3, and a substitute close enough to the claimed model that even checking every response cannot cap the theft. Seeded Monte Carlo, pure-Python, 10 tests, stylised.
In a winner-take-all contest ranked on a noisy holdout of m samples, equilibrium effort is V·an√m/s with a2=a3=1/(2√π) exactly, but the formula stops being an equilibrium once V/σ² passes a ceiling (12.35, 7.78, 6.11, 5.60, 5.80 for n=2, 3, 5, 10, 20) that sits below the zero-rent limit and falls to half of it at n=20. The organiser's optimal holdout is min(mcap, (wVan/2sκ)²): when evaluation is cheap the ceiling, not cost, binds. Quadrature checked against Monte Carlo and brute-force best replies. Pure-Python, 11 tests, stylised.
Proper scoring rules are truthful only for risk-neutral agents. For a CARA verifier the log score yields reported odds exactly equal to true odds^(1/(1+k)), k = αb; the Brier score yields logit p = logit r + k(2r−1), which the principal can invert exactly. Summing reported logits under-extremises (log-loss 0.332 vs 0.214 at k=2); correcting with the mean k under heterogeneous verifiers is worse than not correcting; a log-score report needs true belief 0.964 to clear a 0.9 accept threshold at k=0.5. A binarised lottery rule is truthful for every increasing utility at a 2.6–27% certainty-equivalent cost. Pure-Python, 12 tests, stylised.
When an audit challenge is the hash of the prover's own commitment, a cheater simply re-rolls until the challenge misses its corrupted steps, so expected profit is exactly G−c/p (p = C(T−k,q)/C(T,q)) and the stake plays no role. Deterrence needs q ≈ ln(G/c)·T/k opened steps against ln2·T/k for a post-commitment beacon: 10×–60× more for G/c = 210…260. Proof-of-work on the challenge has a closed-form optimum x* = v/λp − c0. Real SHA-256 grinding matches the geometric law. Pure-Python, 12 tests, stylised.
An LMSR with liquidity b routes like Hedge with rate 1/b, but the tuned b needs the horizon T. A bt = c√t schedule with c* = 1/(2√ln N) pays exactly √2 over the horizon-aware bound (1.36 rising to 1.41 measured); the doubling trick is 1.70× worse than the continuous schedule against a price-reactive adversary; and self-tuning liquidity bt = Δt−1/ln N makes the subsidy equal the accumulated mixability gap (1.3 against 102 on easy data) with regret at most 2Δ. Regret analysis only. Pure-Python, 10 tests, stylised.
Capacity-constrained expert routing is a softmax with a per-expert price, the Lagrange multiplier of its capacity, and the dual is smooth and concave. Any price vector gives a computable upper bound and, after repair toward the uniform assignment, a feasible lower bound, so a verifier certifies near-optimality from prices alone (gap below 10−4 at the optimum, always above the true suboptimality). Sign-update balancing has a sampling floor of about 2.5/√B in max relative overload that no step size removes, plus a step-proportional limit cycle on a fixed batch (22.6% at γ=0.2, 1.2% at 0.01). Two-expert Gaussian price of balance is closed form with price shift equal to the median gap; a Hoeffding audit of ln(2N/δ)/(2ε2) tokens covered 400 of 400 trials. Synthetic scores only. Pure-Python, 10 tests, stylised.
In optimistic verification a fraud pays G unless a challenge is included within w blocks; the attacker controls each proposer w.p. ρ and otherwise pays b to censor. The exact attacker recursion V(n) = ρV(n−1) + (1−ρ)max(−S, V(n−1)−b) gives a closed-form deterrence window (0 mismatches in 5000 instances; Monte Carlo agrees) with a gamble-first, bribe-last optimal attack. A luck-only analysis underestimates the window 100–170×; with an exogenous bribe price the window is 63 blocks for every stake from 10 to 1600; if the bounty is paid as a priority fee the price becomes θS and S·w ≈ G/((1−ρ)θ). Pure-Python, 9 tests, stylised.
When reporting costs c, a truthful verifier paid the score gain over an anchor α abstains exactly when |p−α| < √c (Brier) or KL(p‖α) < c (log), so silence is an interval of signals and carries evidence unless the anchor is a symmetric prior. At prior 0.1 the outcome rate among reporters is 0.57; an aggregator that drops silent verifiers has log-loss 0.62 against 0.02 for one that uses silence at n=12 (it worsens as verifiers are added); a stale anchor makes silence point at the wrong state. Quadrature and seeded Monte Carlo, pure-Python, 12 tests, stylised.
A drift tolerance is a quantile, but compensation depends on expected shortfall, which is not elicitable alone (a mixture moves ES 1.6→2.24). The scale-free score ln e + (v + (x−v)+/(1−α))/e − 1 elicits (VaR, ES) jointly with exact excess law; misreporting ES by a factor r costs ln r + 1/r − 1 (0.307 at ½, 0.193 at 2), matched to quadrature within 2·10−5. A quantile-only tolerance leaves ES/VaR = a/(a−1) uncovered under Pareto drift (6× at a=1.2); auditing needs ~2,000 samples for a 20% understatement at index 4 and the CLT plan fails for index ≤ 2. Pure-Python, 10 tests, stylised.
A verifier reporting expit(aL+b) for the true posterior logit L is overpaid-for-error by exactly E[(r−p)²] under Brier and E[KL(p‖r)] under log score. Brier is bounded (a hard 0/1 report still beats the prior at μ=1) but log is not: raw log score ranks a higher-resolution verifier first only for slope a in (0.264, 2.49), so at a=4 a weaker calibrated verifier wins, while recalibrated scores never reverse. Recalibrating on n outcomes costs about tr(HI−1)/2n excess Brier (0.264/n, simulation within ~10% for n≥100), beating raw pay beyond n≈20–80. Quadrature and seeded simulation, pure-Python, 12 tests, stylised.
When agents bet a fraction λ of wealth Kelly-style, the clearing price is the λ·wealth-weighted mean belief, total wealth is conserved, and λ=1 is exactly the Bayes mixture. Market log-loss exceeds expert i’s by at most ln(1/si)/λi on any sequence (loose on i.i.d. data), the growth-optimal fraction is (π−p)/(q−p), and moving the price against calibrated others costs Vχ²(p0‖p): equal to LMSR b·KL at b=2V for small shifts but 7.5× stiffer at p=0.99. On a truth that switches regimes, full Kelly is wrong about half of every segment (regret about 1630 at T=4000) while λ of 0.1–0.2 cuts it 3–7×. Binary events, static experts. Pure-Python, 11 tests, stylised.
A searcher who buys before and sells after a victim's LMSR trade extracts exactly the victim's slippage tolerance times its fair cost (εC0, error 1.4×10−14 over 216 instances), with a closed-form front-run of about εb/(1−p) shares, so return on capital falls as 1/b. A proportional fee of about v(1−p)/(2b) makes it unprofitable at any tolerance; the victim's optimal tolerance grows only like √log of the stakes; pro-rata batching keeps 0.989–0.999 of the extraction and uniformly random ordering cuts it exactly 3×. Pure-Python, 13 tests, stylised.
For Gaussian reports N(m,s²) both rules have exact expected scores. Overconfidence costs at most σ(√2−1)/√π = 0.234σ under CRPS but is unbounded under log (4995 nats at s=0.01σ); mean errors cost linearly versus quadratically; CRPS is 1-Lipschitz in the realised outcome (log slope 75/σ in our example); a plug-in fit from n samples costs 5σ/(8√πn) versus 1/n; and per-round score variance is finite for Student-t tails ν>2 (CRPS) versus ν>4 (log), which matters for sequential tests. Gaussian family, one verifier. Pure-Python, 9 tests, stylised.
A microbatch crosses L stages held by workers that come and go. The drop probability is the exact binomial tail P(Bin(L,q)>s) with stage outage q = ρ + (1−ρ)(1−a)r, so replicas cannot lift success above the shared-domain floor (1−ρ)L: at L=48, ρ=10−3 no r reaches a 1% drop rate, but allowing one skipped stage makes r=3 enough. At a=0.9 a four-stage skip budget cuts the workers for a 10−3 drop rate from 240 to 96; under a per-skip quality loss κ the cost-optimal design is skip-heavy for cheap skips and moves to replication as κ grows (gain over no-skip 2.9× down to 1.08×). Independent outages, multiplicative skip penalty. Pure-Python, 11 tests, stylised.
Not from one re-execution (variance’s level sets are not convex), but two independent ones suffice: D=(y1−y2)²/2 is unbiased with variance σ4(κ+1)/2. Brier excess is exactly (r−σ²)²; the scale-free loss D/r+ln r has excess 1/λ+ln λ−1, so halving the report costs 0.307 and doubling 0.193. Catching a 10% misreport at 95% takes about 2–4 thousand tasks (2z²(κ+1)/(λ−1)², simulated 0.93–0.97); disjoint pairs are 1.8× worse than the sample variance at n=10; with Pareto tail index 3 the error decays like m−1/3, not m−1/2. Pure-Python, 10 tests, stylised.
When verifiers are paid against a judge whose label flips with rates e0, e1, any proper score elicits the noisy probability e0+γp (γ=1−e0−e1), the Brier incentive shrinks by γ², and rankings of truthful verifiers reverse at η*=0.25. The backward-corrected surrogate score is exactly unbiased for the true loss, at a 1/γ payment spread and (balanced case) 1/γ² more evidence; misestimated rates produce a closed-form affine bias whose cost falls as 1/m in gold checks. Pure-Python, 12 tests, stylised.
Multi-task peer prediction pays 2G·Cov of two reports. If lazy verifiers copy a shared per-task default (the same public model’s guess) pay becomes 2G[aiajpq + (1−ai)(1−aj)d(1−d)], effort is a coordination game with threshold a* = (k/2G + s)/(pq + s), and the all-lazy profile is always an equilibrium paying 2G·d(1−d): equal to honest pay when the default matches the prior, 1.19× it at p=0.3, d=0.5. Closing it with gold checks needs payment mass (2Gs+k)/(1−accD), larger than the honest pay itself. Pure-Python, 9 tests, stylised.
If truth arrives only on audited tasks and the audit rate depends on the report (say g(r)=a+br), “score when audited” is no longer proper: the verifier shades by about −bp(1−p)/(2(a+bp)) and, for steep b, hides at r=0 (Brier excess 0.25 at p=0.5). Weighting the audited loss by 1/g(r) is exactly proper for any audit rule, at variance E[B²]/g−L² and payout cap 1/gmin; the Neyman audit allocation minimises variance but gains only 3–11% over uniform. Pure-Python, 9 tests, stylised.
For fixed reports rA, rB and binary outcomes with frequency q, the Brier difference is a two-point gamble and A is better exactly when q is on A’s side of the midpoint π=(rA+rB)/2. Betting a fraction λ of wealth on it gives an anytime-valid e-process whose best bet grows at exactly KL(q‖π), so the expected decision time is ln(1/α)/KL. A z-test checked after every task falsely declares a winner in 19–38% of null runs at nominal 5%; a uniform mixture over bets stays at or below 3.8% and costs 15–41% extra tasks; a bet twice too large has negative growth. Fixed reports, i.i.d. outcomes. Pure-Python, 7 tests, stylised.
The plug-in multi-task payment (agreement minus the agreement implied by empirical frequencies) is exactly twice the sample covariance of two verifiers’ reports, so its variance is available in closed form and matches full enumeration; it is √2 less noisy than drawing fresh penalty tasks and pays a constant reporter exactly 0. Under limited liability a verifier who does no work still collects a noise rent ≈ σ/√(2π) (0.020 against 0.208 honest at n=100). A deductible removes it in closed form, but killing 99% of the rent costs the honest verifier 54% of its pay. Detection needs 56–329 tasks for g=0.7–0.3 (simulated power 0.94–0.95), and ranking two close verifiers takes ~870. Binary conditionally independent reports. Pure-Python, 9 tests, stylised.
Log score is ideal for rare faults but a confident wrong report costs unbounded stake. Extending the log generator past [ε,1−ε] by its second-order Taylor polynomial gives a strictly proper score, identical to log up to a constant inside, with worst-case payment exactly ln((1−ε)/ε)+1/(1−ε). Per unit of payment range it has 63× Brier’s curvature at p=10−3 but loses to Brier above a closed-form crossover (≈0.07), and ε=p is the best cutoff for truth p.
In a saturating contribution game v(S)=1−exp(−Σwi) every estimator variance is exact. Permutation sampling always pays out exactly v(N) but is noisy; size-stratified sampling has 6–8× lower variance (exactly zero for equal contributors) yet misses the pot by up to 7% in a run; reversing each permutation cuts RMSE 1.6× at no cost; Hoeffding sample counts are 4–5× larger than needed, and stratification finds the top-3 payees with about 4× fewer samples. Stylised, n≤10. Pure-Python, 9 tests.
For K-ary reports the Brier, spherical and log scores have exact regrets and exact worst cases (1−2pmin+‖p‖² for Brier, ‖p‖−pmin for spherical). Per unit of payment range the spherical score gives exactly √K times Brier’s incentive at a uniform truth, but both bounded scores nearly ignore a dropped rare class: at a 1% class the loss is 1.3×10−4 (Brier) and 1.0×10−4 (spherical) against 0.15 for log. Multiclass follow-up to tangent-log. Pure-Python, 6 tests.
Extending x ln x below a cutoff ε by its second-order Taylor polynomial gives a strictly proper K-class score that equals −ln ry whenever every rj≥ε and has payment range exactly 1−ln ε, the same for any K. Per unit of range it has 3× Brier’s rare-class incentive at a 5% class and 63× at 0.1%, the best cutoff is the rarest class’s mass, and a verifier that zeroes out a 1% class loses a closed-form 0.005 (Brier 1.3×10−4, log unbounded). Closes the gap left open in categorical-scores. Pure-Python, 7 tests.
A verifier who reports only the order of K classes can be paid with a score linear in the outcome indicator. It is strictly proper, and swapping two classes at adjacent ranks costs exactly (pi−pj)(wr−wr+1), linear in the gap. Per unit of payment range that beats a Brier-derived ranking whenever the gap is below 1/(K−1) (2.5× at gap 0.1, 250× at 0.001, K=5). Equal spacing maximises the smallest incentive, ranking everything costs K−1 times the mode, a top-k set costs the same as the mode, and the sample size to detect a swap is identical to Brier’s. Pure-Python, 7 tests.
For ordered fault severities the ranked probability score is Brier on the cumulative distribution: strictly proper with exact regret Σ(Rk−Pk)², so moving mass ε a distance d costs exactly dε² where Brier charges 2ε² for every d. Pooling adjacent classes costs exactly half of Brier’s, and every threshold probability is within √regret of the truth. The price: per unit of payment range RPS gives Brier’s incentive only for a maximal-distance shift (1/(K−1) for adjacent ones). Extends categorical-scores. Pure-Python, 7 tests.
When some workers cheat, drift is a mixture and the mean, which squared loss elicits, lands where almost no task lies (at a 30% cheater 6σ away, the mean’s window holds 0.15 of the mass versus 0.48 at the mode). The mode is not elicitable, but the centre of the width-2α window with the most mass is, with the bounded loss 1[|y−r|>α]. Regret is an exact window-mass difference; the best window is α=σ for normal drift and γ/√3 for Cauchy (no mean exists); an equal bimodal mixture has one α-mode iff α exceeds a closed-form root α*; and under 10–40% contamination the sample α-mode has ~0 bias while the mean is off by 5ε, at a 3.7× RMSE cost when clean. Pure-Python, 7 tests.
The Winkler interval score is strictly proper for the pair of quantiles, with closed-form regret and an optimal expected score of exactly 4sφ(z)/α. Misreporting the width by the same factor costs more when narrow at 95% coverage but more when wide at 80%, so there is no universal rule that overconfidence is worse. Under Cauchy drift the scores have no mean, yet paired differences are bounded, so evaluate verifiers against a benchmark report.
Giving each of L layers its own tolerance lets a prover hide the sum of them: L·c(L,α)σ versus zα√Lσ for one test on the total, 6.6× more at L=16 and 23× at L=128. The sum test’s power depends only on the total shift; the exact (Šidák) max test’s depends on how it is spread, the prover’s best split is even (log Φ is concave), and the max test catches a 2.7σ one-layer shift half the time but lets 16σ through spread over all 16 layers. A union of both at α/2 caps the hidden budget at the sum test’s (7.8σ) while keeping one-layer sensitivity. Gaussian, independent layers, known σ. Pure-Python, 8 tests.
If a report of “fault” gets the job rejected and the outcome is seen only on acceptance, scoring observed jobs is improper: verifiers shade under the threshold to get scored, and every job is accepted (1.1–2.8× optimal decision loss at thresholds 0.7–0.2). A reserve payment for rejection makes truth optimal iff the score’s entropy minimum τs is at least the threshold τd, and then it is unique, 1+τd²−2τdτs. Plain Brier (τs=½) therefore fails above τd=½; recentring the score by a term linear in the outcome fixes every threshold, cheapest at τs=τd with rent τ3/3. Exploration with inverse-propensity payment is also proper but multiplies payment variance by about 1/ε. Stylised, single verifier. Pure-Python, 10 tests.
The Winkler interval score is the sum of two pinball losses: proper for the equal-tailed quantile interval with exact regret (2/α)[PR(l,α/2)+PR(u,1−α/2)], finite even for Cauchy drift where the expected score does not exist, but its payment grows without bound in the miss distance. A width-plus-miss loss (u−l)+λ1[miss] is bounded by width+λ and elicits the density level set, the shortest interval for its coverage: 22–31% narrower than equal-tailed on lognormal(0,1) drift. The price is statistical: to detect a 20% understatement of a normal tolerance it needs 3–48× more tasks for α≥0.1 and about the same at α=0.01. Pure-Python, 9 tests.
Checking a claimed matrix product by A(Br) ≈ Cr needs a tolerance t, so the error bound becomes size-dependent: a rank-one corruption of Frobenius norm F is missed by a Gaussian probe with probability exactly erf(t/(√2F)), rank one is the worst case for fixed F, and m probes give erfm (4 probes for 1% at 3t). Rademacher probes miss a two-entry corruption with probability ½ at every size. Emulated float32 noise grows ≈n0.9; a hashed probe with free retries lets a cheater grind in 1/erf tries (125 at 100t). Stylised, additive corruption. Pure-Python, 7 tests.
A Glosten–Milgrom market maker facing an informed share μ with accuracy q moves its posterior log-odds by exactly 2·atanh(μ(2q−1)) per net buy, so its price path is an LMSR with b* = 1/(2 atanh m) (verified to 2×10−16). A wrong b costs log loss only in a transient whose peak is scale-free in m and 1.8–2.5× worse when overconfident; the LMSR subsidy tends to b* ln 2, exactly the spread the GM maker charges. Pure-Python, 10 tests, stylised.
A conformal tolerance (the k-th order statistic of n honest drift scores) has an exact, distribution-free false-slash rate (n+1−k)/(n+1) — but only 51–56% of calibration sets deliver a rate ≤ α. A PAC-safe tolerance exists iff n ≥ ln δ/ln(1−α) (459 runs at 1%/1%), and its margin is hiding room for a cheater: the threshold sits 1.26× above the true quantile at n=2000 on Pareto-3 drift. Gaussian plug-in tolerances over-slash skewed drift up to 17×; pooling calibration across mixed hardware slashes the noisy class 4.8× too often and lets the quiet class hide 2.9× more. Pure-Python, 7 tests.
A proportional fee f on an LMSR verification market gives every trader an exact no-trade band [q/(1+f), (q+f)/(1+f)] of width f/(1+f), so an informed trader leaves the price at q/(1+f). At price ½ a signal of log-likelihood ratio λ moves the price iff f < tanh(λ/2) = 2a−1, above which the market is dead; fee revenue on a monotone path is exactly fb ln((1−p0)/(1−pT)). With ten 0.65-accurate traders, the break-even fee (≈0.11) raises Brier error from 0.115 to about 0.16 and revenue is hump-shaped in f. Naive traders, synthetic signals. Pure-Python, 8 tests.
Drawing m verifiers from a pool of N with B Byzantine, majority capture is exactly hypergeometric: zero once m ≥ 2B+1 and up to 26× below the with-replacement binomial (N=100, B=30, m=41: 1.4×10−4 vs 3.6×10−3). For failure 2−40 the exact size is a steady ≈0.90 of ln(1/ε)/KL(½‖β) while Hoeffding over-sizes it up to 2.2×. With stake-weighted draws only the Byzantine stake share counts: 20 of 100 nodes at 4× stake capture a 41-member committee half the time. A threshold-t rule trades wrong acceptance (2.7×10−7 to 1.1×10−16) against stalls (2.7×10−7 to 3.3×10−2). Static adversary, exact computation. Pure-Python, 11 tests.
No. A hedger with no information at all keeps its expected calibration error below √(K+1)(1/(2K)+1/√T) against any outcome sequence, even one that sees its forecast distribution: ECE 0.016 at T=2000 while its Brier score is 0.254 against 0 for a verifier who knows the rule. A lazy constant forecaster is slashed; the hedger passes every calibration threshold tried, but a Brier-gap test against an informed benchmark catches it in 100/100 runs.
A verifier who checks a claim one noisy check at a time and stops when it likes, paid a proper score, follows a symmetric threshold rule (confirmed against dynamic programming over all policies). Accuracy is pk = 1/(1+((1−a)/a)k) and expected checks are k(2pk−1)/(2a−1), exactly. Participation needs a score scale κ ≥ 4c/(2a−1)² under Brier (log needs about half), Brier’s threshold is ln(κ(2a−1)²/((1−a)c))/λ within one step, and adaptive stopping matches a fixed-sample verifier’s accuracy with 2–3× fewer checks. Binary state, known accuracy. Pure-Python, 8 tests.
Verifiers who are paid for being right and see earlier verdicts herd: once two more revealed signals point one way than the other, everyone copies. With signal accuracy a the cascade is wrong with probability exactly (1−a)²/(a²+(1−a)²) (0.155 at a=0.7) and forms after 2/(a²+(1−a)²) revealed signals (3.4), so accuracy is capped at 0.845 however many verifiers join, versus ≈1 for an independent majority of 101. A sealed first batch of m ≥ 3 lifts the cap (0.875 at m=3, 0.949 at 11) and beats a majority of the same paid size. Recursion checked against fully Bayesian simulated agents. Stylised, symmetric signals. Pure-Python, 9 tests.
Stake sets the audit rate a = G/(G+S); the audits then form a queue with offered load R = λas. Erlang-C waiting matches simulation (P(wait) 0.409 vs 0.407), and square-root staffing c = R + 1.06√R is within 1.5 servers of the exact minimum for R ≥ 100, so the spare capacity needed falls from 60% at R=5 to 1.1% at 104. Stake and headcount trade off with first-order optimum G+S = √(ws G/(rd0)): total cost 23.6 at the optimum versus 76.8 with too little stake and 65 with too much. Heavy-tailed audit times make Allen–Cunneen pessimistic (0.97 vs 0.63); batches of simultaneous audits make it optimistic (0.82 vs 1.45 at batch size 4). Stylised costs, FIFO, static outages. Pure-Python, 8 tests.
If a fault is flagged by fewer than half of the verifiers (0.45 detection, 0.05 false alarms), majority vote is wrong on faulty jobs with probability 0.84 at n=101 and 0.96 at n=301. The surprisingly-popular rule (verdict plus predicted verdict fraction) reduces for truthful Bayesian verifiers to an exact fraction threshold θ = v/(1−u+v) and errs 2.1×10−5 on faulty jobs at n=101, needing 47 votes for 10−3 total error against 36 for a Bayes rule that knows the detector. A wrong believed prior wrecks finite-n accuracy (0.51 error), a wrong believed detector quality breaks the limit, and Byzantines who vote clean and predict “everyone flags” break it at exactly 13.6%. Stylised, truthful reports assumed. Pure-Python, 7 tests.
In a sequential LMSR verification market the verifier in position k earns in expectation b·I(y; sk | s<k), a conditional mutual information, so seat rents telescope to the maker’s expected loss (at most b ln 2); an explicit cost-function simulation agrees to three decimals. Rents fall with position, the successive ratio approaching e−C (Chernoff information) from below; order only redistributes a fixed total (a 0.9-accurate verifier gets 0.368 of 0.407 first, 0.303 last). With entry cost c, accuracy improves roughly as 1/b: 11 verifiers at b=0.25 (92%), 41 at b=5 (99.6%). Myopic traders, symmetric signals, monotonicity numerical. Pure-Python, 8 tests.
For a fixed pipeline order, greedy filling is an exact test of a target stage time (agreeing with an independent dynamic program, with and without memory caps), and every order satisfies W/V ≤ T* < W/V + m wmax/V. A speed-blind equal split costs exactly v̄/vmin times the lower bound (2.40× at log-speed spread 0.5, 8.25× at 1.0) while speed-aware cutting stays within 1.4% at 240 layers. What is left is the device order: at 14 layers and 6 devices the worst order is 1.34× the best, fast-first and slow-first sorts do no better than an arbitrary order (all about 1.16× optimal), and pairwise-swap search gets within 1.1%; the penalty fades to 1.03× at 224 layers. Memory that shrinks as speed grows inflates the bottleneck 1.7×. No communication cost, static speeds. Pure-Python, 8 tests.
Waiting for the fastest k of n workers has exact round time s + (Hn−Hn−k)/μ for exponential tails, and for Pareto tails the mean is finite iff n−k+1 > 1/α, so with α ≤ 1 waiting for everyone has infinite expected round time. For SGD on a quadratic the time to accuracy has a minimum k and an interior optimum (34× faster than waiting for all at zero fixed cost, 1.12× at large fixed cost). If speed correlates with data, the fastest-k average is biased by Σ(πi/k−1/n)θi; Horvitz–Thompson reweighting removes it but only pays when the bias is large.
Not without incentives. With diminishing returns and a peer-rollout discount θ, symmetric Nash play gives every agent exactly the learning level of a lone agent whatever the swarm size (total effort caps at (a/c−1)/θ), while the efficient level grows linearly in N: welfare per agent is 4.5× higher at N=256. At θ=1 a single agent generates everything. A Pigouvian matching subsidy covering θ(N−1)/(1+θ(N−1)) of cost implements the optimum exactly, and junk rollouts beat honesty iff c−ε > p(τ+F).
If a round pays the first k of n finishers a prize R and workers buy speed at cost c per unit rate, the win probability’s slope at the symmetric point telescopes to (1−k/n)(Hn−Hn−k), so equilibrium speed is R(n−k)(Hn−Hn−k)/(nc) and the round time is exactly nc/((n−k)R). Paying every finisher buys no speed at all; for a fixed budget, speed alone wants winner-take-all (0.10 at k=1 versus 3.2 at k=16 for n=32), and only the statistical floor on k justifies more winners. Recruiting more workers barely helps: total speed bought saturates at kR/c. Exponential races, linear cost, symmetric risk-neutral workers; equilibrium checked on a grid. Pure-Python, 12 tests.
If only the first k of n finishers are paid, a slow worker entering at a vanishing rate wins with probability rate × E X(k) of the fast workers, which gives an exact exit rule: workers with cost ratio cs/cf ≥ nf/(nf−k) stay out entirely, and paying k ≥ nf never excludes anyone (checked by best-entry payoffs at thresholds 4/3, 2, 4). At cost ratio 4 with four fast workers, k ≤ 3 shuts the slow ones out and k=4..7 readmits them (share of prizes 0.21→0.46 against a fair 0.5). The note also proves the telescoping identity behind the symmetric race and shows that with convex speed cost, headcount does buy speed. Two cost types, exponential races, grid-checked equilibria.
If only awake modules report and each awake module’s wealth is multiplied by 1+η(ℓ̂−ℓi), the ledger is exactly budget balanced, sleeping wealth never moves (each regime keeps a private ledger), and a module’s regret against the market on its awake rounds is at most ln(1/πi)/η + ηni in its own awake time (the exponential variant pays ηT/8 and is not budget balanced). Admitting a module with wealth ε costs each incumbent ln(1/(1−ε))/η in its bound. With recurring regimes the ledger matches the per-round oracle (0.1004 vs 0.1000, regret about 2.7 whatever the number of specialists) while a forced-to-report Hedge sits at the generalist (0.30) and fixed share is worse (0.34–0.36). The bound is loose (measured regret 2.7 against a bound near 103); losses bounded, wake sets exogenous. Pure-Python, 8 tests.
With Gaussian policies whose mean has moved by δ standard deviations, the importance weight has exact moments E w = 1 and E w² = eδ², so the effective-sample fraction is e−δ² (0.37 at δ=1) and a learner needing fraction ρ accepts a lag of √ln(1/ρ)/drift policy versions. Truncating weights has closed-form lost mass, bias and variance (matched by simulation); the best cap cuts the mean-shift estimator’s MSE 1.9× at δ=1, 12.8× at δ=2 and about 750× at δ=3, and finite-sample ESS is optimistic once weights are heavy-tailed. Equal-variance Gaussians, one statistic. Pure-Python, 7 tests.
For a report of an expected drift r ∈ ℝd with noise covariance Σ, every quadratic Bregman score −(y−r)TA(y−r) is proper and charges a misreport D exactly DTAD. Against a trusted reference the per-task gap has exact mean DTAD and variance 4DTAΣAD for any noise law, and Cauchy–Schwarz shows A=Σ−1 has the best signal to noise for every deviation at once, needing 4z²/(DTΣ−1D) tasks. An isotropic score has efficiency at least 4κ/(1+κ)² (Kantorovich), attained by a deviation split between the extreme eigendirections: 25× more tasks at condition number 100, and power 0.29 against 0.80 at 48 tasks in simulation. Per-layer normalisation alone barely helps; with Σ estimated from m reference draws, efficiency is 0.61 at m=2d and 0.95 at m=100. Quadratic scores, trusted reference, finite covariance. Pure-Python, 7 tests.
Yes, if it declares after seeing its loss. The wealth ledger pays each awake module exactly its leave-one-out saving, ηWA(1−pi)Si, but a module that sleeps whenever its own loss exceeds θ earns ηpBθ(1−θ)/2 per unit wealth against an equal-skill honest rival (best 1/8 at θ=1/2) and takes the market from a 0.1 share in about 130 rounds, while the router’s realised loss stays at 0.5. Declared before the router serves, the same wealth is a real saving that falls from 0.125 to 0.011 as the module’s signal about its own loss gets noisier. A sleeping tax that stops the exploit must be at least ηpB/2, a fixed-share rate that halves an honest specialist asleep 90% of the time in 6 rounds, so commitment, not taxation, is the fix. Two modules, uniform losses, threshold strategies; mean-field predictions 3–8% slow. Pure-Python, 9 tests.
Sparse mixture-of-experts routing as a capped Hedge market: expert prices are min(1, λ wi) with a single shadow price λ and an exact KL projection. Regret against the best fixed k-set stayed within k ln(N/k)/η + ηTk/2 in every run (41–58% of it, not proved here); plain normalisation prices an expert above 1 in 282 of 300 rounds and understates loss 3.2×; systematic sampling realises exactly k distinct experts with 8–14× lower loss variance. Oblivious losses only. Pure-Python, 6 tests.
If a worker paid for T steps runs only (1−f)T, the verifier’s log-loss test (null sd σ′, level α) hides exactly the compute at which the loss curve, inverted, crosses the noise band: L((1−f*)T) = L(T)eσ′(zα+zP). For a power law with a loss floor this is closed form and grows as the reducible share r falls (6% at r=1 but 64% at r=0.05 for σ′=0.02). Run-to-run seed noise is a floor that no evaluation size removes: with 2% seed noise a 5% cap is unreachable for r ≥ 0.05, while without it 104 to 4×106 eval samples suffice. On exactly solvable quadratic GD the predicted detection probability matches simulation within 1.5 points, and the loss test is worth only about 4.4 random step audits at best (0.16 once training is floor-dominated). Stylised: one statistic, normal approximation, known curve family. Pure-Python, 14 tests.
A dispute goes to 3 jurors; the loser may pay a fee (proportional to panel size) to appeal to 11, then 27. If the fee lies in the window V(1−q) ≤ j n < V q, only the wrongly ruled truthful side appeals and the final error is exactly the product of the tiers’ error rates; below the window both sides appeal and only the last tier counts, above it nobody appeals. With jurors 70% accurate and prize 100 the smallest deterring panel is 11 (23 at prize 1000, 41 at 104); the 3→11→27 ladder errs 2.4×10−4 at 5.8 expected juror seats, against 12.6% for a single 7-seat panel, while a 9-juror middle tier leaks 0.78 wrong-side appeals per dispute. If jurors share a common bias with probability ρ, error cannot fall below ρ(1−a) however many tiers are added. Independent jurors, myopic appeals, no juror incentives or bribery; exact results agree with 200,000-trial simulation.
Hash-derived audit challenges under free retries: cheat profit exactly G − c/p, deterrence needs ln(G/c)·T/k opened steps vs ln2·T/k for a beacon (10×–60×), stake is irrelevant, and the proof-of-work optimum is x* = v/λ_p − c0.
When an audit challenge is the hash of the prover's own commitment, a cheater simply re-rolls until the challenge misses its corrupted steps, so expected profit is exactly G−c/p (p = C(T−k,q)/C(T,q)) and the stake plays no role. Deterrence needs q ≈ ln(G/c)·T/k opened steps against ln2·T/k for a post-commitment beacon: 10×–60× more for G/c = 210…260. Proof-of-work on the challenge has a closed-form optimum x* = v/λp − c0. Real SHA-256 grinding matches the geometric law. Stylised.
Verifiers as informational complements: decision value is zero below a closed-form committee size while mutual information is submodular; myopic hiring buys nothing and leave-one-out pay is a sawtooth that vanishes.
Exact value of verifier committees for an accept/slash decision: value is zero below a closed-form minimum committee size (4 at π=0.05, q=0.7) even though mutual information is submodular, 24–34% of triples violate diminishing returns, myopic marginal-value hiring buys nothing (ratio 0 to the optimum) and leave-one-out pay is a parity sawtooth that falls 7× below average value at 40 verifiers. Stylised.
Verifier committees from a finite pool: exact hypergeometric capture (zero once m ≥ 2B+1, up to 26× below binomial), exact size ≈0.90 of ln(1/ε)/KL(½‖β) vs Hoeffding up to 2.2× too large, stake-weighted draws depend only on Byzantine stake share (20 of 100 nodes at 4× stake capture a 41-committee w.p. ½), and the threshold safety/liveness trade-off.
Drawing m verifiers from a pool of N with B Byzantine, majority capture is exactly hypergeometric: zero once m ≥ 2B+1 and up to 26× below the with-replacement binomial (N=100, B=30, m=41: 1.4×10−4 vs 3.6×10−3). For failure 2−40 the exact size is a steady ≈0.90 of ln(1/ε)/KL(½‖β) while Hoeffding over-sizes it up to 2.2×. With stake-weighted draws only the Byzantine stake share counts: 20 of 100 nodes at 4× stake capture a 41-member committee half the time. A threshold-t rule trades wrong acceptance (2.7×10−7 to 1.1×10−16) against stalls (2.7×10−7 to 3.3×10−2). Static adversary, exact computation.
Identity splitting vs merging under stake-weighted pools: split-invariant iff the weight is linear in stake, per-head optimum √(Rn/c)−n, sharp deterrence fee Rn/((n+1)(n+2)), wagering split-neutral.
Sybil splitting and whale merging under stake-weighted pools: only linear-in-stake weights are split-invariant, per-head pools are captured at k* = √(Rn/c) − n identities (exact match), a sharp per-identity deterrence fee, exponents above 1 reward merging, and weighted-score wagering is split-neutral. Stylised.
Can a bond tell reliable hardware from unreliable? Single crossing runs the wrong way: reliable rent (θ_H−θ_L)(c+(1+ρ)s_H)/(1−θ_H) is minimised at zero stake, a flat wage is optimal, and a deterrence stake scales rent by (c+(1+ρ)s)/c.
Workers have hidden fault rates and accept a wage-and-stake contract. Single crossing runs the wrong way: the reliable worker is the one who would copy a high-stake contract, so its rent is exactly (θH−θL)(c+(1+ρ)sH)/(1−θH), minimised at zero stake, and with continuous types a flat wage with no stake is optimal (no random 2–4-contract menu beats it). A stake needed for deterrence is a tax: it scales reliable workers’ rent by (c+(1+ρ)s)/c and lowers the pool’s fault rate (0.169→0.089) at 9–55% of profit. Stylised.
Milestone payments without enforcement: a split pre-payment needs only the pooled relationship value (C/(W_r+W_w) vs P/W_r, C/W_w), and front-loading makes the milestone count logarithmic, ⌈ln(1+(V−C)/W)/ln(V/C)⌉ (17 vs 100 at W=1).
A requester and an anonymous worker split a job into milestones, each a stage of pre-payment, work and late payment, with a grim trigger that forfeits the remaining surplus and a relationship value W. A milestone is self-enforcing under some pre-payment split iff its cost is at most the pooled continuation value, so pay-after-delivery needs P/Wr equal milestones, pay-before C/Ww, and the best split C/(Wr+Ww) (110, 25 and 20 in the example), whoever holds the value. Because early defection also forfeits the remaining work, the largest milestone shrinks geometrically and the minimum count is ⌈ln(1+(V−C)/W)/ln(V/C)⌉: 17 instead of 100 at C=100, V=120, W=1, with the first milestone 1−(C−W)/V of the job. Cheap re-entry caps W and costs ln(1/e) milestones. Matched on 2000 random instances. Stylised: complete information, pro-rata value.
Research programme: incentive-compatible verification of outsourced ML training; first measurement on real training finds a tolerance-tau referee passes a skip-steps cheat on 30% of steps at tau = 1e-2 while the held-out loss stays within one seed std, and the loss only suffers at tau about 10x the worst benign drift; milestone 4 prices contracts by linear programme: with a tolerance, audit-only cannot enforce full effort and the joint contract beats both checks only when the score is precise (4 of 45 cells); milestone 6: against a coordinating majority replication adds no deterrence beyond the audit and the stake is flat in the number of workers (140 cells); milestone 5: an agreement term between redundant workers is worth nothing beyond the audit once cheats copy one trajectory (0 of 1,349 random instances), and a proved one-sided bound max(C, g/p - S) holds in 2,755 instances but is vacuous for a noisy score
An open research programme rather than a finished project. A requester pays untrusted workers to train a model; cheating is cheap and the product cannot be checked without redoing the work. The programme asks for the cheapest protocol that makes full-effort training an equilibrium when the checks are a refereed re-execution of a disputed step, a noisy proper score of the final model on held-out data, and agreement among redundant workers, and when honest workers disagree by floating-point drift. It consolidates about 60 stylised projects in this repository (verification-game, audit-allocation, verifier-bribery, effort-elicitation, reproducible-refereed-training and others). Planned: the drift tolerance priced as a cheating margin, a joint contract over audit rate, stake and score with a proved cost frontier, the stake needed against workers who share one cheap trajectory, and measurement on real small-model training. First result (H1, milestone 3): on a 64-64-10 MLP trained on the real scikit-learn digits data over 20 seeds, a referee that accepts a step within L2 distance tau passes a worker that skips, subsamples or lowers precision whenever the alternative is within tau. Benign float16 drift is at most 9×10−3 (median 3×10−5); skipping passes 30% of steps at tau = 10−2 and costs less than one seed standard deviation of held-out loss, and costs 30 standard deviations only at tau = 0.1. At drift-sized tolerances the margin is saved work rather than a worse model. One dataset, one small model and plain SGD; Milestone 4 (H2, first look) solves the cheapest contract as a linear programme on the measured skip actions: once the tolerance exceeds benign drift, audit-only cannot implement full effort at any stake, score-only costs 5.8 compute units at 540 test examples, and the joint contract is strictly cheaper than the better single check in 4 of 45 settings (ratios 0.72 to 0.81, all with 5,000 test examples). A requester who buys the quality the tolerance sanctions instead pays the effort plus one audited step. One model, the skip family only, a Gaussian score; Milestone 5 (H3, H5): with two redundant workers an agreement term lowers the cheapest contract only when cheats cannot coordinate; with one shared cheap trajectory and copying equilibria excluded it never beat the audit in 1,349 random linear-programme instances (the parameters are swept, not measured). A one-sided resolution lower bound max(C, g/p − S) is proved and never violated, exact in 2,410 of 2,755 random instances, but the proposal's constant-factor claim fails (worst ratio 2,093) and the bound is vacuous for a Gaussian score. Milestone 6 (H4): brute-force search over strong equilibria with m = 1 to 7 replicated workers sharing one cheap trajectory finds that a coalition of floor(m/2)+1 escapes replication, and that the stake deterring it, max(0, g/p − 1), does not fall with m (matches in all 140 cells), so the proposal's 1/m law is refuted for a per-job audit; the result is a model check (pure strategies, one shared cheat). H6 is untested. Milestone 34 (H4): with the auditor as a player, a catch reward cannot deter it (it earns 0 in the honest profile), and the bond that does grows about linearly in the number of workers (17 at m = 1, 134 at m = 7; brute force matches the closed form in 440 instances).
Proper scoring & elicitation28Effort & peer prediction9Verification games & slashing19Detection & tolerances14Markets as routers13Prediction-market design9Paying contributors8Decentralised training systems23Digital twins & sim-to-real164LLM chip design loops40Robot manufacturing loops53Ambient AI assistant46Self-replicating manufacturing34Simulation-first design64Engineered clothing45Task-specific AI accelerators40Algorithmic chip-design loops42Open-source purpose-built robots44The software-engineering loop43Adversarial human imitation41Open-source residential construction41Autonomous multi-angle capture34Sensing, imaging and 3D31Energy supply and dense energy storage39Robot societies among people31Agentic co-design of low-cost robots27Laundry-hanging robots25Machine learning on qualitative data23Robots on the building site27Civilizations & group psychology1History & human sciences1
Produced with AI assistance (Claude). Results are from the code in this repository and are simulated or stylised unless the abstract says otherwise; nothing here implies affiliation with or endorsement by any lab, researcher or company cited. MIT licensed.