Chapter 31: Decision Markets and Futarchy

"Vote on values, but bet on beliefs." -- Robin Hanson, Shall We Vote on Values, But Bet on Beliefs? (2013)

Prediction markets, as we have studied them throughout this book, aggregate dispersed information into probability estimates. But what if we could go further? What if, instead of merely predicting the future, markets could actively guide the decisions that shape it? This is the radical promise of decision markets and their most ambitious application, futarchy -- a form of governance in which prediction markets replace (or supplement) deliberation, debate, and voting as the mechanism for choosing policies.

The idea is simultaneously elegant and controversial. If markets can predict the consequences of different policies better than experts or voters, why not let them decide? But the leap from prediction to decision raises profound questions about causation, manipulation, democratic legitimacy, and mechanism design that occupy some of the deepest thinkers in economics, computer science, and political philosophy.

This chapter provides an exhaustive treatment of decision markets and futarchy. We begin with the conceptual foundations, work through the theoretical apparatus, examine real-world implementations (from corporate experiments at Google and HP to DAO governance on Solana), and confront the hard problems that remain unsolved. Along the way, we implement conditional market mechanisms, causal inference tools, and full futarchy simulations in Python.

31.1 The Big Idea: Governance by Prediction

31.1.1 From Information Aggregation to Decision-Making

Throughout this book, we have seen that prediction markets excel at aggregating dispersed information. When a market asks "What will quarterly revenue be?", traders with private signals -- sales data, customer feedback, supply chain intelligence -- trade their way to prices that outperform expert forecasts (Chapter 11). The market's price is not just a number; it is a sufficient statistic that compresses the collective knowledge of all participants.

Robin Hanson, an economist at George Mason University, made the conceptual leap that transformed prediction markets from information tools into governance mechanisms. His insight was deceptively simple: if prediction markets can tell us what will happen, perhaps they can also tell us what we should do.

The key innovation is the conditional prediction market: instead of asking "What will GDP be next year?", we ask "What will GDP be next year if we adopt Policy A?" and simultaneously "What will GDP be next year if we adopt Policy B?" If the market for Policy A shows a higher expected GDP, we adopt Policy A. The market has made the decision for us.

31.1.2 Hanson's Futarchy Proposal

In his seminal 2000 paper (later published in the Journal of Political Philosophy in 2013), Hanson proposed futarchy as a new form of government:

Futarchy: A system of governance in which elected officials define measures of national welfare, and prediction markets determine which policies are adopted, based on which policies the markets predict will maximize those welfare measures.

The slogan is memorable: "Vote on values, but bet on beliefs."

Under futarchy: 1. Citizens vote (via democratic processes) on welfare metrics -- what constitutes the good society. For example: maximize GDP per capita plus a health index minus a Gini coefficient penalty. 2. For any proposed policy, conditional prediction markets are opened: "If this policy is adopted, what will the welfare metric be in 5 years?" and "If this policy is not adopted, what will the welfare metric be?" 3. The policy is adopted if and only if the conditional market price under the policy exceeds the conditional price without it.

The appeal is profound. Futarchy claims to solve several problems simultaneously:

• Rational ignorance: Voters need not understand complex policy; traders with expertise handle the analysis.
• Special interest capture: It is harder for lobbyists to buy predictions than to buy votes.
• Ideology and tribalism: Markets force participants to put money where their mouths are, penalizing wishful thinking.
• Expert disagreement: The market aggregates across all experts (and non-experts with relevant information) automatically.

31.1.3 The Controversy

Futarchy is also one of the most controversial proposals in institutional design. Critics raise serious objections:

1. Who defines the welfare metric? The entire system depends on the metric being correct. But defining "national welfare" is precisely the hard part of politics -- it is not a technical problem but a values problem.

2. Causal inference: Conditional market prices tell us about correlations, not necessarily causation. If sophisticated traders condition on "Policy A passes," they may also condition on the political context in which Policy A would pass -- which might itself be correlated with good (or bad) outcomes.

3. Manipulation: If the market determines the policy, traders have incentives beyond information revelation. A corporation might lose money on a prediction to gain billions from the resulting policy.

4. Thin markets: Conditional markets split liquidity. If only one of two conditions will actually resolve, half the trading capital is "wasted."

5. Democratic legitimacy: Should market participants (weighted by capital) override the preferences of citizens (weighted equally)?

We will examine each of these objections rigorously in the sections that follow.

31.1.4 The Intellectual Landscape

Futarchy sits at the intersection of several intellectual traditions:

31.2 Conditional Prediction Markets

31.2.1 The Basic Structure

A conditional prediction market is a market that only resolves if a certain condition is met. The canonical structure involves two components:

• The decision variable $D \in \{d_1, d_2, \ldots, d_k\}$: the action or policy under consideration.
• The outcome variable $Y$: the quantity we care about measuring.

For each possible decision $d_i$, we create a market that pays $Y$ if $D = d_i$ and is "called off" (positions returned at cost) if $D \neq d_i$.

Example: A company is deciding between Product Strategy A and Product Strategy B. $Y$ is next-year revenue.

• Market A: pays $Y$ per share if Strategy A is chosen; called off if B is chosen.
• Market B: pays $Y$ per share if Strategy B is chosen; called off if A is chosen.

Let $P_A$ denote the price in Market A and $P_B$ the price in Market B. Under standard rational expectations:

$$P_A = \mathbb{E}[Y \mid D = A, \text{market information}]$$ $$P_B = \mathbb{E}[Y \mid D = B, \text{market information}]$$

If $P_A > P_B$, the market collectively believes that Strategy A will produce higher revenue.

31.2.2 Implementing Conditional Markets

There are several approaches to implementing conditional markets:

Approach 1: Separate Conditional Markets

Create distinct markets for each condition. Each market is independently operated and resolves only if the corresponding decision is made. This is the simplest approach but splits liquidity across markets.

Approach 2: Combinatorial Market with Conditional Tokens (Gnosis Framework)

Use a combinatorial market maker (Chapter 28) with tokens that represent joint states of $(D, Y)$. Traders buy and sell tokens like "Decision A AND Revenue > 100M." Conditional prices are derived by normalizing:

$$P(Y > 100M \mid D = A) = \frac{P(D = A \text{ AND } Y > 100M)}{P(D = A)}$$

This approach preserves liquidity across conditions but requires a more complex market structure.

Approach 3: Call Auction with Conditional Orders

Traders submit orders contingent on the decision. A single clearing mechanism processes all orders simultaneously, resolving the decision and the outcome market together.

31.2.3 Python Implementation: Conditional Market

"""
Conditional Prediction Market Implementation
Implements a basic decision market with two conditions.
"""

import numpy as np
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple
from enum import Enum
import uuid


class Decision(Enum):
    """Possible decisions in the market."""
    A = "A"
    B = "B"
    UNDECIDED = "UNDECIDED"


@dataclass
class ConditionalOrder:
    """An order in a conditional prediction market."""
    trader_id: str
    decision_condition: Decision  # Which decision this order is conditioned on
    quantity: float               # Positive = buy, negative = sell
    limit_price: float           # Maximum price to pay (or min to receive)
    order_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])

    def __repr__(self):
        side = "BUY" if self.quantity > 0 else "SELL"
        return (f"Order({self.order_id}: {side} {abs(self.quantity):.1f} "
                f"units | D={self.decision_condition.value} @ {self.limit_price:.3f})")


class ConditionalMarketMaker:
    """
    Logarithmic Market Scoring Rule (LMSR) based conditional market.

    Maintains separate cost functions for each decision condition.
    """

    def __init__(self, liquidity_param: float = 100.0,
                 outcome_range: Tuple[float, float] = (0.0, 1.0),
                 n_buckets: int = 10):
        """
        Args:
            liquidity_param: LMSR liquidity parameter (b)
            outcome_range: (min, max) of the outcome variable
            n_buckets: Number of outcome buckets for discretization
        """
        self.b = liquidity_param
        self.outcome_range = outcome_range
        self.n_buckets = n_buckets

        # Create outcome buckets
        self.bucket_edges = np.linspace(outcome_range[0], outcome_range[1], n_buckets + 1)
        self.bucket_centers = (self.bucket_edges[:-1] + self.bucket_edges[1:]) / 2

        # Outstanding shares for each (decision, outcome_bucket) pair
        self.shares: Dict[Decision, np.ndarray] = {
            Decision.A: np.zeros(n_buckets),
            Decision.B: np.zeros(n_buckets),
        }

        # Track total cost collected
        self.total_cost = 0.0

        # Trade history
        self.trade_history: List[dict] = []

    def cost_function(self, shares: np.ndarray) -> float:
        """LMSR cost function: C(q) = b * ln(sum(exp(q_i / b)))."""
        # Numerical stability: subtract max
        max_q = np.max(shares / self.b)
        return self.b * (max_q + np.log(np.sum(np.exp(shares / self.b - max_q))))

    def prices(self, decision: Decision) -> np.ndarray:
        """Current prices for each outcome bucket under the given decision."""
        q = self.shares[decision]
        exp_q = np.exp(q / self.b - np.max(q / self.b))
        return exp_q / np.sum(exp_q)

    def expected_value(self, decision: Decision) -> float:
        """Expected value of outcome conditioned on decision."""
        p = self.prices(decision)
        return np.sum(p * self.bucket_centers)

    def buy_outcome_bucket(self, decision: Decision, bucket_idx: int,
                           quantity: float, trader_id: str = "anon") -> float:
        """
        Buy shares in a specific (decision, outcome_bucket) pair.

        Returns:
            Cost of the trade.
        """
        old_cost = self.cost_function(self.shares[decision])
        self.shares[decision][bucket_idx] += quantity
        new_cost = self.cost_function(self.shares[decision])

        cost = new_cost - old_cost
        self.total_cost += cost

        self.trade_history.append({
            'trader_id': trader_id,
            'decision': decision.value,
            'bucket_idx': bucket_idx,
            'bucket_center': self.bucket_centers[bucket_idx],
            'quantity': quantity,
            'cost': cost,
            'new_expected': self.expected_value(decision),
        })

        return cost

    def buy_expected_value_shift(self, decision: Decision, direction: str,
                                 budget: float, trader_id: str = "anon") -> float:
        """
        Shift the expected value up or down using a budget.

        This simulates a trader who believes the outcome will be higher/lower
        than the current market expectation.

        Args:
            decision: Which conditional market to trade in.
            direction: "up" or "down".
            budget: Maximum to spend.
            trader_id: Trader identifier.

        Returns:
            Amount actually spent.
        """
        total_spent = 0.0
        step_size = budget / 20  # Trade in small increments

        for _ in range(20):
            p = self.prices(decision)
            if direction == "up":
                # Buy the highest bucket, sell the lowest
                buy_bucket = self.n_buckets - 1
                sell_bucket = 0
            else:
                buy_bucket = 0
                sell_bucket = self.n_buckets - 1

            cost = self.buy_outcome_bucket(decision, buy_bucket, 1.0, trader_id)
            total_spent += cost

            if total_spent >= budget:
                break

        return total_spent

    def get_decision_signal(self) -> Tuple[Decision, float, float]:
        """
        Returns the market's recommendation.

        Returns:
            (recommended_decision, expected_value_A, expected_value_B)
        """
        ev_a = self.expected_value(Decision.A)
        ev_b = self.expected_value(Decision.B)

        if ev_a >= ev_b:
            return Decision.A, ev_a, ev_b
        else:
            return Decision.B, ev_a, ev_b

    def summary(self) -> str:
        """Print a summary of current market state."""
        ev_a = self.expected_value(Decision.A)
        ev_b = self.expected_value(Decision.B)
        rec, _, _ = self.get_decision_signal()

        lines = [
            "=== Conditional Market Summary ===",
            f"E[Y | D=A] = {ev_a:.4f}",
            f"E[Y | D=B] = {ev_b:.4f}",
            f"Difference (A - B) = {ev_a - ev_b:.4f}",
            f"Market recommends: Decision {rec.value}",
            f"Total trades: {len(self.trade_history)}",
            f"Total cost collected: {self.total_cost:.2f}",
        ]
        return "\n".join(lines)


# --- Demonstration ---

if __name__ == "__main__":
    print("=== Conditional Decision Market Demo ===\n")

    # Create market for a decision between A and B
    # Outcome is revenue (normalized to 0-1 scale)
    market = ConditionalMarketMaker(
        liquidity_param=50.0,
        outcome_range=(0.0, 1.0),
        n_buckets=10
    )

    print("Initial state:")
    print(market.summary())
    print()

    # Trader 1 believes Decision A leads to higher outcomes
    cost1 = market.buy_expected_value_shift(Decision.A, "up", budget=10.0, trader_id="T1")
    print(f"Trader 1 spent {cost1:.2f} pushing A's expected value up")

    # Trader 2 also believes A is better but not by as much
    cost2 = market.buy_expected_value_shift(Decision.A, "up", budget=5.0, trader_id="T2")
    print(f"Trader 2 spent {cost2:.2f} pushing A's expected value up")

    # Trader 3 believes Decision B leads to higher outcomes
    cost3 = market.buy_expected_value_shift(Decision.B, "up", budget=12.0, trader_id="T3")
    print(f"Trader 3 spent {cost3:.2f} pushing B's expected value up")

    print()
    print("Final state:")
    print(market.summary())

31.2.4 Interpreting Conditional Prices

The interpretation of conditional market prices is subtle and important. The price $P_A = \mathbb{E}[Y \mid D = A]$ is a conditional expectation -- it tells us the market's belief about $Y$ given that decision $A$ is made. But this conditioning has a critical ambiguity:

The correlation problem: When the market conditions on $D = A$, it conditions on everything that is correlated with $D = A$. If the decision is made by some external process (a legislature, a CEO), then the market is conditioning not just on the direct effect of the policy, but also on the state of the world in which that policy would be adopted.

For example, suppose a government considering a fiscal stimulus. The stimulus would likely be adopted during a recession. The conditional market $\mathbb{E}[\text{GDP} \mid \text{stimulus}]$ might show lower GDP not because the stimulus hurts the economy, but because the stimulus is adopted precisely when the economy is already weak.

This is the fundamental challenge: we want the causal effect of the decision, but the market gives us a conditional expectation that mixes the causal effect with selection effects.

31.3 Decision Markets in Theory

31.3.1 The Formal Framework

Let us formalize the decision market mechanism. We have:

• A set of possible decisions $\mathcal{D} = \{d_1, d_2, \ldots, d_k\}$
• An outcome variable $Y \in \mathbb{R}$ (the welfare metric)
• A state of the world $\omega$ drawn from some space $\Omega$, which determines both the feasibility of decisions and the outcomes

The key quantities are:

$$\mu_i = \mathbb{E}[Y \mid D = d_i]$$

for each decision $d_i$. The decision rule is:

$$d^* = \arg\max_{d_i \in \mathcal{D}} \mu_i$$

That is, we choose the decision that the market predicts will maximize the expected outcome.

31.3.2 The Causal Challenge: Formal Statement

Define the potential outcome $Y(d)$ as the outcome that would occur if decision $d$ were implemented (regardless of what actually happens). This is the Rubin causal model notation. The causal effect of decision $d_i$ relative to $d_j$ is:

$$\tau_{ij} = \mathbb{E}[Y(d_i)] - \mathbb{E}[Y(d_j)]$$

What the market gives us is:

$$\hat{\tau}_{ij} = \mathbb{E}[Y \mid D = d_i] - \mathbb{E}[Y \mid D = d_j]$$

These are equal if and only if the decision $D$ is independent of potential outcomes conditional on market information:

$$Y(d) \perp D \mid \mathcal{I}_{\text{market}}$$

This is the ignorability or unconfoundedness assumption from causal inference. In general, it does not hold for decision markets because the decision itself may be endogenous -- correlated with unobserved factors that also affect $Y$.

31.3.3 When Does the Decision Market Get It Right?

Hanson (2013) argues that the decision market gets the causal effect right under specific conditions:

1. The decision is randomized: If the mechanism randomly selects which conditional market to "count" (i.e., whether $D = A$ or $D = B$ is implemented), then the selection effect vanishes. This is the market equivalent of a randomized controlled trial.

2. The decision is determined solely by the market: If the decision rule is solely $d^* = \arg\max_i \mu_i$, then traders know that their trading affects the decision. In equilibrium, traders who try to exploit the selection effect would move the market and potentially change the decision, creating a fixed-point problem.

3. Thick markets: With sufficiently many traders, no individual trader can move the market enough to change the decision, so each trader acts as a price-taker and reports truthfully.

The formal result (Hanson, 2013; Othman and Sandholm, 2010) is that under certain equilibrium conditions, decision markets do produce causal estimates. The intuition is that the decision market creates an incentive structure where being "right about the causal effect" is the only reliable way to make money.

However, this result is delicate. It relies on equilibrium reasoning that may not hold in thin or manipulated markets.

31.3.4 Alternative Theoretical Frameworks

Several researchers have proposed modifications to address the causal inference problem:

Chen, Kash, and Ruberry (2014) -- Proposed "decision scoring rules" that directly reward traders for the causal effect, not the conditional expectation. This requires additional structural assumptions.

Page and Clemen (2013) -- Analyzed conditions under which conditional market prices converge to causal effects and showed that even small deviations from the ideal conditions can produce large biases.

Othman and Sandholm (2010) -- Studied the game-theoretic equilibria of decision markets and showed that truthful reporting is a Bayesian Nash Equilibrium under certain conditions, but that multiple equilibria can exist.

31.4 Causal Inference from Markets

31.4.1 The Potential Outcomes Framework Applied

To rigorously analyze whether conditional markets reveal causal effects, we apply the Rubin Causal Model (potential outcomes framework).

For each unit $i$ and decision $d$, define: - $Y_i(d)$: the potential outcome for unit $i$ under decision $d$ - $D_i$: the actual decision applied to unit $i$ - $Y_i^{\text{obs}} = Y_i(D_i)$: the observed outcome

The Average Treatment Effect (ATE) is:

$$\text{ATE} = \mathbb{E}[Y(A)] - \mathbb{E}[Y(B)]$$

The selection bias is:

$$\text{Bias} = \left(\mathbb{E}[Y \mid D = A] - \mathbb{E}[Y \mid D = B]\right) - \text{ATE}$$

$$= \left(\mathbb{E}[Y(A) \mid D = A] - \mathbb{E}[Y(A) \mid D = B]\right) + \left(\mathbb{E}[Y(B) \mid D = A] - \mathbb{E}[Y(B) \mid D = B]\right) / \text{adjustments}$$

In simpler terms, selection bias arises when the decision is correlated with the baseline potential outcome. If $A$ is chosen when things are already going well, then $\mathbb{E}[Y \mid D = A]$ will be inflated not because $A$ caused good outcomes, but because $A$ was selected when outcomes were already going to be good.

31.4.2 The Decision Market Solution

Decision markets attempt to solve the causal inference problem through a clever mechanism:

1. Both conditional markets (A and B) are open simultaneously.
2. The decision is made based on the market prices.
3. Only the market corresponding to the actual decision resolves.

The key insight is that if the decision is solely determined by comparing $P_A$ and $P_B$, then the mapping from market prices to decisions is known to all traders. A trader who believes that $A$ causes better outcomes (regardless of selection) will buy in the $A$-conditional market, pushing $P_A$ up, which makes $A$ more likely to be chosen, which makes their bet more likely to resolve (and pay off).

The equilibrium argument is subtle: in a large market, each trader is a price-taker. Their individual trade does not change the decision. Therefore, they simply report their honest belief about $\mathbb{E}[Y \mid D = d]$ for the decision $d$ they trade on. Since they know the decision rule, they can "undo" the selection effect in their heads and report the causal estimate.

31.4.3 Python Implementation: Causal Analysis

"""
Causal Inference Analysis for Decision Markets.

Simulates scenarios where conditional market prices may or may not
reflect causal effects, and implements diagnostic tools.
"""

import numpy as np
from typing import Tuple, Dict
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt


class CausalDecisionMarketSimulator:
    """
    Simulates a world where we can observe both potential outcomes
    (for analysis) and a decision market that observes only
    conditional expectations.
    """

    def __init__(self, n_worlds: int = 10000, seed: int = 42):
        self.n_worlds = n_worlds
        self.rng = np.random.RandomState(seed)

    def generate_scenario(self,
                          true_effect_A: float = 0.5,
                          true_effect_B: float = 0.3,
                          selection_correlation: float = 0.0
                          ) -> Dict:
        """
        Generate a causal scenario.

        Args:
            true_effect_A: True causal effect of decision A on outcome.
            true_effect_B: True causal effect of decision B on outcome.
            selection_correlation: How correlated the decision is with
                                   baseline outcome (0 = no selection bias).

        Returns:
            Dictionary with potential outcomes, decisions, and observed outcomes.
        """
        n = self.n_worlds

        # Baseline state of the world (unobserved confounder)
        U = self.rng.normal(0, 1, n)

        # Potential outcomes under each decision
        Y_A = U + true_effect_A + self.rng.normal(0, 0.5, n)
        Y_B = U + true_effect_B + self.rng.normal(0, 0.5, n)

        # Decision process: may be correlated with U
        # Higher selection_correlation means D=A is more likely when U is high
        decision_propensity = selection_correlation * U + self.rng.normal(0, 1, n)
        D = (decision_propensity > 0).astype(int)  # 1 = A, 0 = B

        # Observed outcomes
        Y_obs = np.where(D == 1, Y_A, Y_B)

        # True causal quantities
        true_ATE = np.mean(Y_A) - np.mean(Y_B)

        # Naive conditional difference (what a simple market might report)
        naive_diff = np.mean(Y_obs[D == 1]) - np.mean(Y_obs[D == 0])

        # Selection bias
        bias = naive_diff - true_ATE

        return {
            'Y_A': Y_A,
            'Y_B': Y_B,
            'U': U,
            'D': D,
            'Y_obs': Y_obs,
            'true_ATE': true_ATE,
            'true_effect_A': true_effect_A,
            'true_effect_B': true_effect_B,
            'naive_conditional_diff': naive_diff,
            'selection_bias': bias,
            'selection_correlation': selection_correlation,
        }

    def analyze_bias_vs_selection(self,
                                  true_effect_A: float = 0.5,
                                  true_effect_B: float = 0.3
                                  ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        """
        Analyze how selection bias varies with selection correlation.

        Returns:
            (correlations, true_ATEs, naive_diffs)
        """
        correlations = np.linspace(-2, 2, 41)
        true_ates = []
        naive_diffs = []

        for corr in correlations:
            scenario = self.generate_scenario(
                true_effect_A=true_effect_A,
                true_effect_B=true_effect_B,
                selection_correlation=corr
            )
            true_ates.append(scenario['true_ATE'])
            naive_diffs.append(scenario['naive_conditional_diff'])

        return correlations, np.array(true_ates), np.array(naive_diffs)

    def simulate_decision_market_equilibrium(self,
                                              true_effect_A: float = 0.5,
                                              true_effect_B: float = 0.3,
                                              n_traders: int = 50,
                                              n_rounds: int = 100
                                              ) -> Dict:
        """
        Simulate a decision market where traders know the decision rule
        and report beliefs accordingly.

        This demonstrates how the decision market mechanism can recover
        causal effects even when naive conditioning would not.
        """
        prices_A = [0.5]  # Starting price for E[Y|A]
        prices_B = [0.5]  # Starting price for E[Y|B]

        # Traders have noisy signals about the true effects
        trader_signals_A = true_effect_A + self.rng.normal(0, 0.2, n_traders)
        trader_signals_B = true_effect_B + self.rng.normal(0, 0.2, n_traders)

        for round_num in range(n_rounds):
            # Each round, a random trader updates the market
            trader = self.rng.randint(n_traders)

            # Trader knows that the decision will be based on
            # which price is higher, so they report their causal estimate
            signal_A = trader_signals_A[trader]
            signal_B = trader_signals_B[trader]

            # Update prices via simple averaging (Bayesian-like)
            learning_rate = 1.0 / (round_num + 2)
            new_price_A = prices_A[-1] + learning_rate * (signal_A - prices_A[-1])
            new_price_B = prices_B[-1] + learning_rate * (signal_B - prices_B[-1])

            prices_A.append(new_price_A)
            prices_B.append(new_price_B)

        return {
            'prices_A': np.array(prices_A),
            'prices_B': np.array(prices_B),
            'true_effect_A': true_effect_A,
            'true_effect_B': true_effect_B,
            'final_price_A': prices_A[-1],
            'final_price_B': prices_B[-1],
            'market_recommendation': 'A' if prices_A[-1] > prices_B[-1] else 'B',
            'correct': (prices_A[-1] > prices_B[-1]) == (true_effect_A > true_effect_B),
        }


# --- Demonstration ---

if __name__ == "__main__":
    sim = CausalDecisionMarketSimulator()

    print("=== Causal Inference from Decision Markets ===\n")

    # Scenario 1: No selection bias
    s1 = sim.generate_scenario(
        true_effect_A=0.5, true_effect_B=0.3, selection_correlation=0.0
    )
    print("Scenario 1: No selection bias (random assignment)")
    print(f"  True ATE (A - B): {s1['true_ATE']:.4f}")
    print(f"  Naive conditional diff: {s1['naive_conditional_diff']:.4f}")
    print(f"  Selection bias: {s1['selection_bias']:.4f}")
    print()

    # Scenario 2: Positive selection bias
    s2 = sim.generate_scenario(
        true_effect_A=0.5, true_effect_B=0.3, selection_correlation=1.5
    )
    print("Scenario 2: Positive selection bias (A chosen when U is high)")
    print(f"  True ATE (A - B): {s2['true_ATE']:.4f}")
    print(f"  Naive conditional diff: {s2['naive_conditional_diff']:.4f}")
    print(f"  Selection bias: {s2['selection_bias']:.4f}")
    print()

    # Scenario 3: Negative selection bias
    s3 = sim.generate_scenario(
        true_effect_A=0.5, true_effect_B=0.3, selection_correlation=-1.5
    )
    print("Scenario 3: Negative selection bias (A chosen when U is low)")
    print(f"  True ATE (A - B): {s3['true_ATE']:.4f}")
    print(f"  Naive conditional diff: {s3['naive_conditional_diff']:.4f}")
    print(f"  Selection bias: {s3['selection_bias']:.4f}")
    print()

    # Decision market simulation
    dm = sim.simulate_decision_market_equilibrium(
        true_effect_A=0.5, true_effect_B=0.3, n_traders=100, n_rounds=200
    )
    print("=== Decision Market Equilibrium ===")
    print(f"  Final price A: {dm['final_price_A']:.4f} (true: {dm['true_effect_A']:.4f})")
    print(f"  Final price B: {dm['final_price_B']:.4f} (true: {dm['true_effect_B']:.4f})")
    print(f"  Market recommends: Decision {dm['market_recommendation']}")
    print(f"  Correct? {dm['correct']}")

31.4.4 Limitations of Causal Inference from Markets

Even with the theoretical arguments in favor, several practical limitations remain:

1. Finite trader effects: The equilibrium argument relies on each trader being a price-taker. In thin markets, a single trader can move the price and change the decision, breaking the argument.

2. Common knowledge requirements: Traders must understand the decision rule and reason about how their trades affect the decision. This is a strong cognitive requirement.

3. Multiple equilibria: There can be self-fulfilling prophecy equilibria. If traders believe $A$ will be chosen and trade accordingly, the market can "lock in" to either decision, regardless of the true causal effects.

4. Dynamic manipulation: A patient manipulator can slowly move prices, conditioning the behavior of other traders who interpret prices as signals.

31.5 Corporate Prediction Markets for Decisions

31.5.1 The Corporate Use Case

While futarchy in government remains largely theoretical, corporate prediction markets for decision-making have been implemented and studied in real organizations. The corporate context is in many ways the ideal testing ground:

• Decisions are clearly defined (launch product A or B, invest in project X or Y).
• Outcome metrics are measurable (revenue, profit, market share).
• The population of traders (employees) has genuine private information.
• The stakes are high enough to motivate participation.
• The organization controls the decision process.

31.5.2 Google's Internal Markets

Google operated one of the most studied corporate prediction markets from 2005 to the mid-2010s. While most of Google's markets were standard prediction markets (e.g., "Will Chrome reach 20% market share by Q4?"), some were structured as decision-support tools:

• Product launch predictions: Markets on expected user adoption conditional on different launch strategies.
• Hiring predictions: Markets on candidate success conditional on different team assignments.
• Resource allocation: Markets on project success probabilities used to inform investment decisions.

Key findings from the Google experience (Cowgill, Wolfers, and Zitzewitz, 2009): - Markets were well-calibrated overall. - There was an optimism bias (prices slightly too high for positive outcomes), possibly due to selection of enthusiastic participants. - Markets outperformed simple baselines but the advantage over well-structured expert panels was modest.

31.5.3 Hewlett-Packard Experiments

HP conducted some of the earliest controlled experiments with corporate prediction markets in the late 1990s and early 2000s (Chen and Plott, 2002). Their focus was on sales forecasting:

• Markets were opened among small groups of HP employees to predict printer sales.
• Despite having only 8-12 traders, the markets significantly outperformed HP's official sales forecasts.
• The improvement came largely from aggregating information that existed in different departments (sales, manufacturing, marketing) but was not effectively shared.

The HP experiments demonstrated that prediction markets could work in corporate settings even with very few participants, provided those participants had genuinely diverse information.

31.5.4 Microsoft

Microsoft operated internal prediction markets for software development:

• Markets predicted ship dates, bug counts, and feature completion.
• These were primarily predictive (not decision-conditional), but the information was used to inform resource allocation decisions.
• Markets were notably more accurate than project manager estimates for ship dates.

31.5.5 Ford Motor Company

Ford experimented with prediction markets for vehicle demand forecasting:

• Markets predicted sales volumes for different models under different incentive programs.
• This represented a decision-adjacent use: the market was not directly choosing the incentive program, but the conditional structure ("What will F-150 sales be if we offer 0% financing?") informed the decision.
• Results were mixed: markets were good at short-term forecasting but struggled with longer horizons.

31.5.6 Lessons from Corporate Implementations

31.6 Implementing a Decision Market

31.6.1 Design Principles

Implementing a decision market requires careful attention to several design dimensions:

1. Define the Decision Space

The set of possible decisions must be: - Mutually exclusive and collectively exhaustive (MECE) - Clearly defined (no ambiguity about what each decision entails) - Feasible (each decision must be implementable)

2. Define the Outcome Metric

The welfare metric $Y$ must be: - Measurable and verifiable - Available within a reasonable time frame - Sensitive to the decision (not swamped by external factors) - Resistant to manipulation (not easily gamed)

3. Design the Conditional Market Structure

Choose between: - Separate conditional markets (simpler, but splits liquidity) - Combinatorial tokens (more complex, preserves liquidity) - Conditional limit orders (most flexible, hardest to implement)

4. Specify the Decision Rule

The rule mapping market prices to decisions. Options include: - Argmax: Choose the decision with the highest conditional expected outcome. - Threshold: Choose a new policy only if its expected outcome exceeds the status quo by some margin. - Randomized: With some probability, randomize the decision (to maintain incentive compatibility). - Advisory: Market prices inform but do not determine the decision (this is not technically futarchy, but is more commonly implemented).

5. Design the Resolution Protocol

How the market resolves after the decision is made: - The conditional market matching the actual decision resolves normally. - Conditional markets for decisions not taken are voided (positions returned at purchase price). - Define the oracle or data source for the outcome metric.

31.6.2 Python Implementation: Decision Market Framework

"""
Complete Decision Market Framework.

Implements a full decision market with:
- Multiple decision alternatives
- LMSR-based conditional markets
- Decision rule
- Resolution protocol
"""

import numpy as np
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple, Callable
from enum import Enum
import json


@dataclass
class MarketConfig:
    """Configuration for a decision market."""
    decisions: List[str]
    outcome_description: str
    outcome_range: Tuple[float, float] = (0.0, 100.0)
    n_outcome_buckets: int = 20
    liquidity_param: float = 100.0
    decision_rule: str = "argmax"  # "argmax", "threshold", "randomized"
    threshold_margin: float = 0.0   # For threshold rule
    random_prob: float = 0.1        # For randomized rule


@dataclass
class TraderAccount:
    """A trader's account in the decision market."""
    trader_id: str
    balance: float = 1000.0
    positions: Dict[str, np.ndarray] = field(default_factory=dict)
    trade_count: int = 0
    total_pnl: float = 0.0


class DecisionMarket:
    """
    Full decision market implementation.

    Supports multiple decisions, LMSR pricing, and various decision rules.
    """

    def __init__(self, config: MarketConfig):
        self.config = config
        self.n_decisions = len(config.decisions)
        self.n_buckets = config.n_outcome_buckets
        self.b = config.liquidity_param

        # Outcome bucket structure
        self.bucket_edges = np.linspace(
            config.outcome_range[0], config.outcome_range[1],
            self.n_buckets + 1
        )
        self.bucket_centers = (self.bucket_edges[:-1] + self.bucket_edges[1:]) / 2

        # Share state for each decision
        self.shares: Dict[str, np.ndarray] = {
            d: np.zeros(self.n_buckets) for d in config.decisions
        }

        # Trader accounts
        self.traders: Dict[str, TraderAccount] = {}

        # Market state
        self.is_open = True
        self.decision_made: Optional[str] = None
        self.actual_outcome: Optional[float] = None

        # History
        self.trade_log: List[dict] = []
        self.price_history: Dict[str, List[float]] = {
            d: [self._expected_value(d)] for d in config.decisions
        }

    def register_trader(self, trader_id: str, initial_balance: float = 1000.0):
        """Register a new trader."""
        self.traders[trader_id] = TraderAccount(
            trader_id=trader_id,
            balance=initial_balance,
            positions={d: np.zeros(self.n_buckets) for d in self.config.decisions}
        )

    def _cost_function(self, shares: np.ndarray) -> float:
        """LMSR cost function."""
        max_q = np.max(shares / self.b)
        return self.b * (max_q + np.log(np.sum(np.exp(shares / self.b - max_q))))

    def _prices(self, decision: str) -> np.ndarray:
        """Current outcome prices for a given decision."""
        q = self.shares[decision]
        exp_q = np.exp(q / self.b - np.max(q / self.b))
        return exp_q / np.sum(exp_q)

    def _expected_value(self, decision: str) -> float:
        """Expected outcome value conditioned on decision."""
        p = self._prices(decision)
        return np.sum(p * self.bucket_centers)

    def trade(self, trader_id: str, decision: str,
              bucket_idx: int, quantity: float) -> dict:
        """
        Execute a trade.

        Args:
            trader_id: Who is trading.
            decision: Which conditional market.
            bucket_idx: Which outcome bucket.
            quantity: How many shares (positive = buy, negative = sell).

        Returns:
            Trade receipt dictionary.
        """
        if not self.is_open:
            raise ValueError("Market is closed.")
        if trader_id not in self.traders:
            raise ValueError(f"Unknown trader: {trader_id}")
        if decision not in self.config.decisions:
            raise ValueError(f"Unknown decision: {decision}")
        if not (0 <= bucket_idx < self.n_buckets):
            raise ValueError(f"Invalid bucket index: {bucket_idx}")

        trader = self.traders[trader_id]

        # Calculate cost
        old_cost = self._cost_function(self.shares[decision])
        self.shares[decision][bucket_idx] += quantity
        new_cost = self._cost_function(self.shares[decision])
        cost = new_cost - old_cost

        # Check if trader can afford it
        if cost > trader.balance:
            # Revert
            self.shares[decision][bucket_idx] -= quantity
            raise ValueError(
                f"Insufficient funds: cost={cost:.2f}, balance={trader.balance:.2f}"
            )

        # Update trader state
        trader.balance -= cost
        trader.positions[decision][bucket_idx] += quantity
        trader.trade_count += 1

        # Record
        receipt = {
            'trader_id': trader_id,
            'decision': decision,
            'bucket_idx': bucket_idx,
            'bucket_range': (self.bucket_edges[bucket_idx],
                           self.bucket_edges[bucket_idx + 1]),
            'quantity': quantity,
            'cost': cost,
            'new_balance': trader.balance,
            'new_expected': self._expected_value(decision),
        }
        self.trade_log.append(receipt)

        # Update price history
        for d in self.config.decisions:
            self.price_history[d].append(self._expected_value(d))

        return receipt

    def get_recommendation(self) -> Tuple[str, Dict[str, float]]:
        """
        Get the market's decision recommendation.

        Returns:
            (recommended_decision, {decision: expected_value})
        """
        expectations = {d: self._expected_value(d) for d in self.config.decisions}

        if self.config.decision_rule == "argmax":
            rec = max(expectations, key=expectations.get)
        elif self.config.decision_rule == "threshold":
            # Compare alternatives to the first (status quo)
            status_quo = self.config.decisions[0]
            sq_val = expectations[status_quo]
            best_alt = max(
                [d for d in self.config.decisions[1:]],
                key=lambda d: expectations[d]
            )
            if expectations[best_alt] > sq_val + self.config.threshold_margin:
                rec = best_alt
            else:
                rec = status_quo
        else:  # randomized
            rec = max(expectations, key=expectations.get)
            # Note: actual randomization would happen at decision time

        return rec, expectations

    def make_decision(self, decision: Optional[str] = None) -> str:
        """
        Make the decision and close the market for new trading.

        Args:
            decision: Override decision. If None, use market recommendation.

        Returns:
            The decision made.
        """
        if decision is None:
            decision, _ = self.get_recommendation()

        self.decision_made = decision
        self.is_open = False
        return decision

    def resolve(self, actual_outcome: float) -> Dict[str, float]:
        """
        Resolve the market with the actual outcome.

        Returns:
            {trader_id: pnl} for each trader.
        """
        if self.decision_made is None:
            raise ValueError("No decision has been made yet.")

        self.actual_outcome = actual_outcome

        # Find which bucket the outcome falls in
        outcome_bucket = np.searchsorted(self.bucket_edges[1:], actual_outcome)
        outcome_bucket = min(outcome_bucket, self.n_buckets - 1)

        pnl = {}
        for tid, trader in self.traders.items():
            # Payout from the decision that was made
            position = trader.positions[self.decision_made]
            payout = position[outcome_bucket]  # 1 unit per share in correct bucket

            # Return cost basis for voided conditional markets
            # (simplified: just track PnL on the resolved market)
            trader.total_pnl = payout  # Simplified PnL
            trader.balance += payout
            pnl[tid] = payout

        return pnl

    def summary(self) -> str:
        """Generate a summary of market state."""
        lines = ["=" * 50]
        lines.append("DECISION MARKET SUMMARY")
        lines.append("=" * 50)
        lines.append(f"Outcome: {self.config.outcome_description}")
        lines.append(f"Decisions: {', '.join(self.config.decisions)}")
        lines.append(f"Status: {'OPEN' if self.is_open else 'CLOSED'}")
        lines.append(f"Total trades: {len(self.trade_log)}")
        lines.append("")

        for d in self.config.decisions:
            ev = self._expected_value(d)
            lines.append(f"  E[Y | D={d}] = {ev:.2f}")

        rec, _ = self.get_recommendation()
        lines.append(f"\nRecommendation: {rec}")

        if self.decision_made:
            lines.append(f"Decision made: {self.decision_made}")
        if self.actual_outcome is not None:
            lines.append(f"Actual outcome: {self.actual_outcome:.2f}")

        lines.append("=" * 50)
        return "\n".join(lines)


# --- Demonstration ---

if __name__ == "__main__":
    # Create a decision market for choosing a product strategy
    config = MarketConfig(
        decisions=["Strategy_A", "Strategy_B", "Strategy_C"],
        outcome_description="Expected revenue (millions $)",
        outcome_range=(0, 100),
        n_outcome_buckets=20,
        liquidity_param=50.0,
        decision_rule="argmax"
    )

    market = DecisionMarket(config)

    # Register traders
    for i in range(5):
        market.register_trader(f"trader_{i}", initial_balance=500.0)

    print("=== Decision Market Simulation ===\n")
    print(market.summary())

    # Simulate trading: traders have different beliefs
    # Trader 0 believes Strategy A will yield ~70M
    market.trade("trader_0", "Strategy_A", 14, 10.0)  # Bucket around 70

    # Trader 1 believes Strategy B will yield ~80M
    market.trade("trader_1", "Strategy_B", 16, 12.0)  # Bucket around 80

    # Trader 2 believes Strategy A will yield ~65M
    market.trade("trader_2", "Strategy_A", 13, 8.0)   # Bucket around 65

    # Trader 3 believes Strategy C will yield ~60M
    market.trade("trader_3", "Strategy_C", 12, 7.0)   # Bucket around 60

    # Trader 4 believes Strategy B will yield ~75M
    market.trade("trader_4", "Strategy_B", 15, 9.0)   # Bucket around 75

    print("\nAfter trading:")
    print(market.summary())

    # Make decision based on market
    decision = market.make_decision()
    print(f"\nDecision made: {decision}")

    # Resolve with actual outcome
    actual = 78.5  # Actual revenue turned out to be $78.5M
    pnl = market.resolve(actual)
    print(f"Actual outcome: ${actual}M")
    print(f"Trader PnL: {pnl}")

31.6.3 Resolution Considerations

The resolution protocol is critical and must address several issues:

Voided markets: When decision $A$ is chosen, the conditional market for $B$ is voided. Traders who bought positions in the $B$-conditional market get their money back. This creates an asymmetry: losing trades in the non-chosen market are refunded, while losing trades in the chosen market are not. This is by design -- it ensures that traders only bear risk in the market that actually resolves.

Time to resolution: The outcome metric may take months or years to materialize. During this period, traders' capital is locked up. This creates liquidity costs that may deter participation, especially for long-horizon decisions.

Metric gaming: Once the metric is defined and the decision is made, there may be incentives to manipulate the metric itself (rather than the decision). For example, if the metric is "stock price in 6 months," insiders might manipulate the stock price.

31.7 The Manipulation Problem

31.7.1 The Core Concern

Decision markets create a new type of manipulation incentive that does not exist in standard prediction markets. In a standard market, a manipulator who pushes the price away from the truth will lose money to better-informed traders. The market is self-correcting.

In a decision market, manipulation can be profitable because it changes the decision. Consider:

• A pharmaceutical company trades in a decision market on "Should the FDA approve Drug X?"
• The company buys shares pushing up "GDP conditional on approving Drug X."
• If this moves the decision toward approval, the company gains far more from selling Drug X than it lost on the market manipulation.

This is the "buying a decision" problem: the cost of market manipulation may be small relative to the value of the resulting policy change.

31.7.2 Formal Analysis of Manipulation

Let $C_m$ be the cost of manipulating the market (the expected loss from pushing prices away from truth) and $V_m$ be the value of the resulting decision change to the manipulator. Manipulation is profitable when:

$$V_m > C_m$$

The cost $C_m$ depends on: - Market liquidity ($b$ in the LMSR): Higher liquidity means more capital required to move prices. - Number of informed traders: More informed traders push back against manipulation. - Price impact: How much the price moves per dollar traded.

The value $V_m$ depends on: - The manipulator's stake in the decision outcome: Direct financial interest, political power, etc. - The sensitivity of the decision to market prices: How much price movement is needed to flip the decision.

31.7.3 Hanson's Defense

Hanson (2013) argues that manipulation is less of a problem than it appears:

1. Manipulation is costly: A manipulator must continuously trade against better-informed traders. Each manipulative trade loses money in expectation (to traders with genuine information). The manipulator is effectively subsidizing information aggregation.

2. Manipulation improves liquidity: Manipulative trades increase market volume and attract more informed traders, who profit from correcting the manipulation. This can actually improve market quality.

3. Double-edged sword: If manipulation is cheap, so is counter-manipulation. Parties harmed by the manipulated decision can profitably trade against the manipulator.

4. Empirical evidence: Studies of prediction market manipulation (e.g., Rhode and Strumpf, 2004, on presidential election markets) find that manipulation attempts have small and transient effects.

31.7.4 Critiques of the Defense

However, several researchers have challenged Hanson's optimism:

1. Asymmetric information about manipulation: Informed traders may not know that manipulation is occurring. They might interpret the manipulated price as a signal from someone with genuine information, leading to an "information cascade" that reinforces the manipulation.

2. Rational response to manipulation: If traders know manipulation is possible, they may discount market prices, reducing the market's informativeness. In the extreme, the market can break down (a "lemons problem" for information).

3. Budget constraints: While counter-manipulation is theoretically profitable, the traders who would benefit from correcting the manipulation may not have the capital to do so. The manipulator may have deeper pockets than any individual informed trader.

4. Strategic patience: A manipulator need not move the price all at once. Gradual manipulation over time can look like genuine trading and be harder to detect.

31.7.5 Defensive Mechanisms

Several mechanisms have been proposed to reduce manipulation:

31.8 Thin Market Problem

31.8.1 The Liquidity Split

Conditional prediction markets suffer from a fundamental liquidity problem: by conditioning on different decisions, they split the available trading interest across multiple markets.

If a standard prediction market on outcome $Y$ would attract $N$ traders and $L$ dollars of liquidity, a conditional market with $k$ decision alternatives will have approximately $N/k$ traders and $L/k$ liquidity per conditional market. In practice, the split may be even worse because:

1. Some traders may not have strong beliefs about the conditional outcomes.
2. The "call off" feature (voided markets for non-chosen decisions) reduces the expected return on capital, deterring participation.
3. The complexity of conditional markets raises the barrier to entry.

31.8.2 Consequences of Thin Markets

Thin markets have several negative consequences for decision quality:

Higher noise: With fewer traders, each individual has more price impact. Idiosyncratic beliefs (rather than aggregate information) have more influence.

Wider spreads: Market makers charge more to compensate for inventory risk, making it more expensive for informed traders to express their views.

Slower information incorporation: With fewer trades, new information is reflected in prices more slowly.

Vulnerability to manipulation: With less liquidity, the cost of price manipulation is lower (see Section 31.7).

Reduced incentive compatibility: The theoretical results that guarantee causal inference from decision markets rely on each trader being a price-taker. In thin markets, this assumption is violated.

31.8.3 Quantifying the Problem

Consider an LMSR-based conditional market with liquidity parameter $b$. The cost of moving the price from $p$ to $p'$ (for a single binary outcome) is approximately:

$$C \approx b \cdot |p' - p|$$

For a decision market with $k$ alternatives, if the total subsidy budget is $B$, each conditional market gets $b = B/k$. The cost of manipulation is reduced by a factor of $k$ compared to a single market.

For example, with $k = 5$ decision alternatives and a total budget of $\$50{,}000$, each conditional market has $b = \$10{,}000$. Moving a conditional price by 10% costs only about $\$1{,}000$ -- potentially cheap for a well-funded manipulator.

31.8.4 Solutions

1. Market Subsidization

The decision-making institution (company, government, DAO) can subsidize the conditional markets by providing liquidity. The LMSR market maker is a natural vehicle: the institution funds the market maker, accepting that it will lose money to informed traders. This loss is the cost of information acquisition.

The optimal subsidy level balances the cost of the subsidy against the expected improvement in decision quality. If the decision has value $V$ and the market improves the decision probability by $\Delta p$, the expected benefit is $V \cdot \Delta p$. The subsidy should be set so that marginal cost equals marginal benefit.

2. Focused Decision Markets

Rather than opening conditional markets on all possible decisions, focus on the most promising 2-3 alternatives. This concentrates liquidity and trading interest.

3. Sequential Markets

Open conditional markets sequentially: first compare the top 2 alternatives. Once a winner emerges, compare it against the next alternative. This tournament structure reduces the number of simultaneous markets.

4. Combinatorial Markets

Use a single combinatorial market (Chapter 28) that covers all (decision, outcome) pairs. Liquidity is shared across all conditions because the market maker operates on the joint distribution.

5. Reward for Participation

Offer bonuses or rewards for trading in conditional markets, independent of trading profits. This attracts marginal traders who would not otherwise participate.

31.9 Futarchy in Practice

31.9.1 From Theory to Reality

Futarchy has been discussed primarily as a theoretical proposal since Hanson introduced it in 2000. For most of its history, no serious attempt was made to implement it in real governance. This changed with the emergence of blockchain technology and decentralized autonomous organizations (DAOs).

31.9.2 Gnosis and the Futarchy Vision

Gnosis, an Ethereum-based prediction market platform, has been among the most vocal proponents of futarchy in the blockchain space. Their vision:

1. Use conditional tokens (a token standard they developed) to represent claims contingent on decisions.
2. Build automated market makers (AMMs) that operate on conditional token pairs.
3. Deploy these in DAO governance: proposals are evaluated through conditional markets rather than (or in addition to) token votes.

The Gnosis conditional token framework (CTF) allows creating tokens for any combination of conditions and outcomes. For example:

• Token A: "Pays 1 DAI if Proposal X passes AND the DAO's treasury value is above $10M in 6 months"
• Token B: "Pays 1 DAI if Proposal X fails AND the DAO's treasury value is above $10M in 6 months"

If Token A trades at a higher price than Token B, the market believes Proposal X will increase treasury value.

31.9.3 Meta-DAO on Solana

The most significant real-world implementation of futarchy is Meta-DAO, launched on the Solana blockchain. Meta-DAO uses futarchy as its primary governance mechanism:

How it works: 1. Anyone can submit a proposal (e.g., "Hire developer X at salary Y"). 2. Two conditional markets are created: - "What will the META token price be if this proposal passes?" - "What will the META token price be if this proposal fails?" 3. Trading occurs over a defined period (typically days). 4. At the end, if the "pass" conditional price exceeds the "fail" conditional price, the proposal is executed automatically.

Design choices: - Welfare metric: META token price. This is controversial (see Section 31.10) but has the advantage of being continuously observable and hard to manipulate. - Resolution: Token price at a random time point after the decision is made, to prevent manipulation at a known resolution time. - Liquidity: Provided through an AMM funded by the DAO treasury.

Results (as of 2025): - Meta-DAO has processed dozens of governance proposals through futarchy. - Token-price-based futarchy tends to favor proposals that are perceived as positive for short-term token value. - Participation has been concentrated among a small number of sophisticated traders, raising concerns about oligarchic tendencies. - Some proposals that were widely supported by the community were rejected by the market (and vice versa), creating governance tension.

31.9.4 Theoretical vs. Practical Futarchy

The gap between Hanson's theoretical proposal and real-world implementations is substantial:

31.9.5 Other Experiments

Augur (2018-present): While not strictly futarchy, Augur's decentralized prediction markets have been used informally for decision-relevant predictions. However, low liquidity and front-running issues have limited their effectiveness.

Colony (2017-present): Colony, a DAO framework on Ethereum, has explored prediction-market-based reputation and decision-making, though their implementation diverges significantly from pure futarchy.

GitcoinDAO experiments: Gitcoin has discussed using prediction markets to evaluate the impact of grants, which would be a form of decision market applied to resource allocation.

31.9.6 Scaling Challenges

Scaling futarchy from small DAO decisions to larger governance contexts faces several challenges:

1. Complexity of decisions: Real governance involves complex, multi-dimensional decisions with long causal chains. Markets may struggle with this complexity.
2. Metric specification: Defining a welfare metric that captures what matters is increasingly difficult as the scope of governance grows.
3. Regulatory concerns: Financial prediction markets face regulatory scrutiny in most jurisdictions.
4. Public understanding: For futarchy to be legitimate, the public must understand how it works. This is a high bar.
5. Integration with existing institutions: Futarchy does not exist in a vacuum. It must interact with legal systems, constitutions, international agreements, etc.

31.10 Ethical and Philosophical Considerations

31.10.1 Technocratic Governance

Futarchy is, at its core, a technocratic proposal: replace deliberation and political judgment with a market-based mechanism. This raises profound concerns:

The values problem: Hanson says "vote on values." But values and beliefs are not neatly separable. What we believe about the world shapes what we value, and vice versa. The idea that we can cleanly separate values (voted on) from beliefs (traded on) is philosophically contested.

Procedural vs. consequentialist legitimacy: Democratic governance derives its legitimacy partly from the process (everyone has an equal voice) and partly from outcomes. Futarchy maximizes consequentialist legitimacy (better outcomes) at the expense of procedural legitimacy (equal participation).

Expertise and capital: In markets, influence is proportional to capital and trading skill. This privileges the wealthy and financially sophisticated. Even if they make "better" decisions in some metric, the procedural injustice may be unacceptable.

31.10.2 The Welfare Metric Problem

The choice of welfare metric is the Achilles' heel of futarchy. Consider:

1. GDP as welfare metric: Maximizing GDP might lead to policies that increase GDP while worsening inequality, environmental quality, or social cohesion.

2. Composite metrics: We could use a weighted combination (GDP + health - inequality - pollution). But the weights are themselves value judgments. Who sets them? How are they updated?

3. Goodhart's Law: "When a measure becomes a target, it ceases to be a good measure." If the government optimizes for a specific metric, there will be strong incentives to game that metric.

4. Incommensurability: Some values may be fundamentally incommensurable -- they cannot be reduced to a single scalar metric. How do you weigh cultural heritage against economic efficiency?

5. Temporal scope: Should the metric focus on this generation or include future generations? Discount rates embed profound ethical choices.

31.10.3 Minority Rights

A particularly sharp concern is the protection of minority rights:

If the welfare metric is aggregate (total GDP, average health), policies that benefit the majority at the expense of minorities could score well in the market. Traditional democratic governance has evolved protections (constitutional rights, judicial review, anti-discrimination laws) that are not obviously preserved under futarchy.

Hanson's response is that the welfare metric can be designed to include minority welfare (e.g., include the Gini coefficient with a high weight). But this pushes the problem back to metric design, which is itself a political process.

31.10.4 The Democratic Accountability Gap

In a democracy, citizens can "throw the bums out" -- replace leaders who make bad decisions. Under futarchy, the decision-maker is the market. You cannot vote out a price. If the market makes a bad decision (which it inevitably will, sometimes), there is no clear mechanism for accountability.

This is not merely a theoretical concern. Consider: the market recommends Policy X. Policy X turns out to be catastrophic. Traders who were wrong lost money, but they may be anonymous, diffuse, and bear no responsibility proportional to the harm caused.

31.10.5 A Defense of Futarchy's Ethics

Proponents argue:

1. Existing governance fails too: Democracies regularly adopt terrible policies due to voter ignorance, special interest capture, and short-term thinking. Futarchy need not be perfect; it only needs to be better than the alternative.

2. The market as a moral technology: Like democracy itself, markets are not natural but are designed institutions. We can iterate on the design to incorporate ethical constraints.

3. Hybrid systems: Futarchy need not replace democracy entirely. It can serve as an advisory mechanism, with democratic institutions retaining veto power.

4. Revealed preference: Markets force participants to put their money where their beliefs are. This is a stronger form of accountability than cheap talk in a voting booth.

31.11 Advanced: Designing Better Decision Markets

31.11.1 Scoring-Rule-Based Decision Markets

Traditional decision markets use a market scoring rule (like LMSR) to price conditional securities. An alternative approach uses proper scoring rules directly:

Instead of having traders buy and sell securities, each trader reports a probability distribution over outcomes conditional on each decision. The trader is then scored using a proper scoring rule (e.g., the logarithmic scoring rule) applied to the outcome conditional on the actual decision.

Formally, trader $i$ reports distributions $F_i^{(d)}$ for each decision $d$. If decision $d^*$ is made and outcome $Y$ is observed, the trader receives:

$$S_i = \log f_i^{(d^*)}(Y)$$

where $f_i^{(d^*)}$ is the probability density function of $F_i^{(d^*)}$.

The advantage of this approach is that it avoids the need for a market mechanism entirely. Each trader independently reports their beliefs, and the scoring rule incentivizes truthful reporting. The aggregate prediction is formed by combining reports (e.g., averaging or using a proper aggregation method).

Disadvantages: - No price discovery process (no information from observing others' trades). - Requires specifying the scoring rule and the aggregation method in advance. - Less robust to misspecification of the model.

31.11.2 Combinatorial Decision Markets

When decisions are multi-dimensional (e.g., choosing a budget allocation across multiple departments), the number of possible decisions is combinatorial. A conditional market for each possible decision is infeasible.

Combinatorial decision markets allow traders to express beliefs about arbitrary combinations of decisions and outcomes. For example:

• "If the marketing budget exceeds $1M AND the R&D budget is below $500K, revenue will be below $50M."

This requires a combinatorial market maker (Chapter 28) that can handle exponentially many outcomes. The computational challenges are significant (pricing is #P-hard in general), but approximation algorithms and restriction to common decision structures make it tractable in practice.

31.11.3 Privacy-Preserving Decision Markets

A concern with decision markets is that trading reveals information that traders might prefer to keep private. For example, an employee trading in a corporate decision market might reveal negative views about a project that their manager champions.

Privacy-preserving approaches include:

1. Anonymized trading: Traders' identities are hidden from other participants (though the market operator may know them for compliance).

2. Secure multi-party computation: Traders submit encrypted reports that are combined without revealing individual inputs. The aggregate prediction is public, but no individual contribution is identifiable.

3. Differential privacy: Add calibrated noise to individual trades or reports, ensuring that no observer can infer much about any single trader's beliefs.

4. Zero-knowledge proofs: Traders prove they have a valid position without revealing the position itself.

These approaches trade off information quality (noisy reports, computational overhead) against privacy protection.

31.11.4 Bayesian Decision Markets

Chen et al. (2011) proposed Bayesian decision markets that explicitly model the causal structure:

1. Traders report their beliefs about a causal model linking decisions to outcomes.
2. The mechanism combines these beliefs using Bayesian updating.
3. The decision is made based on the posterior causal model.

This approach addresses the causal inference problem directly but requires traders to articulate (and the mechanism to process) complex causal beliefs, which is a significant practical challenge.

31.11.5 Multi-Period Decision Markets

Real decisions unfold over time. A single conditional market at one point in time may miss important dynamics:

• The optimal decision may change as new information arrives.
• Early market participants may have very different information than late ones.
• The decision itself may be sequential (commit to Phase 1, then decide Phase 2).

Multi-period decision markets allow for: - Rolling decision markets that update the decision at intervals. - Contingent decision trees where each decision opens new conditional markets. - Real-options-style markets where traders can bet on the value of future flexibility.

31.11.6 Recent Research Directions

31.12 Chapter Summary

Decision markets and futarchy represent perhaps the most ambitious application of prediction markets: using market mechanisms not merely to forecast, but to govern. The key ideas of this chapter are:

1. Conditional prediction markets allow traders to express beliefs about outcomes contingent on specific decisions. The price in a conditional market reflects the market's aggregate expectation of the outcome under that decision.

2. Futarchy is Robin Hanson's proposal to use conditional markets for governance: "vote on values, bet on beliefs." Citizens define welfare metrics democratically; markets determine which policies maximize those metrics.

3. The causal inference challenge is fundamental: conditional market prices reflect correlations, not necessarily causation. The decision market mechanism addresses this under certain theoretical conditions (large markets, decision determined by prices), but the conditions may not hold in practice.

4. Corporate prediction markets have demonstrated that conditional-style information aggregation can work in organizational settings, though most implementations have been advisory rather than decision-determining.

5. Manipulation is a heightened concern in decision markets because traders can profit from changing the decision, not just from predicting correctly. Defenses exist but are imperfect.

6. Thin markets arise because conditional markets split liquidity. This reduces information quality, increases vulnerability to manipulation, and undermines the theoretical conditions for causal inference.

7. Practical futarchy has emerged in blockchain DAOs, most notably Meta-DAO on Solana. Early results are mixed: the mechanism functions but faces thin market, welfare metric, and legitimacy challenges.

8. Ethical and philosophical concerns about futarchy are profound: the separation of values and beliefs, the welfare metric problem, minority rights protection, and democratic accountability.

9. Advanced designs including scoring-rule-based markets, combinatorial markets, and privacy-preserving approaches offer potential improvements but remain largely theoretical.

The vision of governance by prediction remains provocative and contested. Whether decision markets will evolve from niche DAO experiments to mainstream governance tools depends on resolving the deep theoretical and practical challenges discussed in this chapter. What is clear is that the intellectual apparatus of prediction markets, mechanism design, and causal inference will be central to this endeavor.

What's Next

In Chapter 32, we turn to Combinatorial Prediction Markets, where we tackle the problem of predicting complex, multi-dimensional outcomes. Combinatorial markets generalize the conditional markets studied here to handle exponentially many possible states. We will learn how automated market makers can operate in these high-dimensional spaces, study computational complexity results, and implement practical combinatorial market mechanisms. The combinatorial framework provides the technical substrate on which large-scale decision markets must ultimately be built.