Mechanism Design, Incentives, and Trust on Blockchains

This article explores the intersection of computer science and economics, particularly focusing on mechanism design, incentives, and different notions of trust. It delves into how economic principles of private information and incentives can be integrated with computational tools, contrasting this with computer science protocols and their inherent assumptions about trust.

Information-Constrained Allocations: An Agrarian Economy Example

The discussion begins with an example of an agrarian economy to illustrate information-constrained allocations. This model, while specific, can be generalized to modern financial markets.

The Model Setup

• Economy Type: Pure exchange economy, one period initially.
• Agents: Two agents, Agent 1 (a villa) and Agent 2 (a central monastery).
• Endowments:
  • Agent 1's endowment (e1) is private, parameterized by theta, which takes realizations from a set with probabilities p(theta). Shocks are private to Agent 1.
  • Agent 2's endowment is public and constant (W).
• Risk Profiles: Agent 1 is risk-averse; Agent 2 is risk-neutral.
• Resource Allocation: Agents agree on a rule f that maps a message m from Agent 1 to Agent 2 into positive or negative transfers of a K-dimensional vector of items. Transfers can be negative, representing an insurance mechanism where Agent 2 insures Agent 1 against random endowment shocks.

The Agent's Decision Problem

Agent 1 observes their theta and then sends a message m to Agent 2. The allocation is f(m). The agent chooses m to maximize their utility, given theta. This leads to an optimal message m* (theta).

Inducing Truth-Telling

A key concept in mechanism design is inducing truth-telling. Instead of requiring Agent 1 to tell the truth, the mechanism is designed to make it in Agent 1's self-interest to reveal their true theta.

• Restricted Message Space: The message space is restricted to the set of possible theta values. Agent 1 can still lie, but only by announcing a different possible theta.
• New Allocation Rule g: A new allocation rule g is defined, which is a composite of the original f and the agent's optimized strategy m*. So, g(theta) represents the allocation if Agent 1 announces theta.
• Incentive Compatibility Constraint: This leads to the core incentive compatibility constraint (Equation 85), which states that the utility from announcing the true theta must be greater than or equal to the utility from announcing any other theta tilde. This constraint ensures that truth-telling is a weakly dominant strategy.
• Outcome: If Agent 1 tells the truth, the allocation g(theta) is achieved, which is the same outcome as the original f with optimal behavior m*. This means the same outcomes can be achieved, but now the search for optimal mechanisms is simplified by imposing this truth-telling constraint.

Optimizing the Allocation Rule

To find the optimal allocation rule, a lambda-weighted sum of the ex-ante expected utilities of the agents is maximized, subject to:

1. Resource Constraint: The total resources are conserved.
2. Incentive Constraint: The truth-telling constraint (Equation 85).

Challenges and Enhancements

• Single Good Economy: If there's only one good, the incentive constraint can be very restrictive, potentially leading to a constant allocation (autarky) because "more is preferred to less" makes lying always beneficial if the allocation depends on theta.
• Multiple Goods: With multiple goods, trade-offs exist, making autarky less likely.
• Randomness (Lotteries): Introducing randomness can enhance the set of possible allocations. If there's differential risk aversion, lotteries can exploit mean-variance trade-offs. This transforms the problem into a linear program, which is computationally tractable using tools like Gurobi.

Multi-Period Extension

The model can be extended to multiple periods, where theta can vary over time, and Markov probabilities govern its evolution. The core idea remains the same: maximize a weighted sum of utilities subject to incentive constraints for each period. The key insight in the multi-period setting is that the allocation rule at a later date can depend on information revealed at an earlier date, allowing for intertemporal trade-offs.

• Dynamic Incentive Constraints: Incentive constraints are applied dynamically. For example, in a two-period model, the second-period truth-telling constraint is applied first, and then the first-period constraint takes into account that agents will tell the truth in the second period.
• Risk Sharing vs. Private Information: Without incentive constraints, a static full risk-sharing rule would be optimal. However, private information prevents full risk sharing.
• Borrowing and Lending: Standard borrowing and lending mechanisms are incentive-compatible even with private information, as agents with low income prefer to borrow and those with high income prefer to lend. However, borrowing and lending is not necessarily the optimal solution because it often leaves the incentive constraints non-binding, implying that a more efficient allocation could be achieved. The optimal solution is a hybrid blend of credit and insurance.

Implementation Without a Planner

The concept of a "planner" in economics refers to the maximization problem. However, in practice, a trusted third party isn't always needed.

• Smart Contracts: The information-constrained allocation rule can be implemented as a "smart contract" – a piece of code that agents voluntarily agree to.
• Commitment and Escrow: To ensure performance, agents can put funds into escrow, guaranteeing that the agreed-upon transfers will occur. This addresses limited commitment problems.
• Encryption: Messages can be kept private using encryption, where the code can operate on encrypted messages without needing to see the actual numbers.
• History and Ledgers: The history of messages and transactions is crucial for optimized allocation rules and needs to be securely recorded, similar to how Bitcoin stores transaction history in Merkle trees.
• Layer 1 vs. Layer 2:
  • Layer 1 (On-chain): Refers to the underlying blockchain (e.g., Ethereum) where transactions are validated by the entire community.
  • Layer 2 (Off-chain): Refers to the execution of smart contracts and mechanisms outside the main blockchain, with only the final transfers being recorded on-chain. This reduces the computational burden and cost of validation.

Protocols and Notions of Trust

This section contrasts the economic perspective of incentives with computer science protocols, particularly regarding trust.

Validation Algorithms

• Proof of Work (Bitcoin): Relies on computational puzzles, where the first to solve validates a batch of transactions. It's secure because most participants are honest, but it's energy-intensive and slow.
• Byzantine Fault-Tolerant (BFT) Algorithms: Can reach consensus even with adversarial or faulty nodes. For practical BFT, 3f + 1 replicates are needed to tolerate f failing nodes. These often involve a rotating leader and a membership list, making them more suitable for closed systems (e.g., within a company).
• Proof of Authority: An extreme version where a single entity (e.g., a central bank) approves everything.
• Proof of Stake: Validators are chosen randomly, and their voting power is proportional to their stake (amount of cryptocurrency held).
• Federated Byzantine Agreement (Ripple, Stellar): Each node decides which other nodes it trusts (a "quorum slice"). Consensus is reached when these quorum slices overlap sufficiently. This algorithm's effectiveness depends on the level of trust within the system.

Incentives to Follow an Algorithm: The Byzantine Generals Problem

This classic computer science problem highlights the tension between following a protocol and individual incentives.

• The Problem: Two generals need to coordinate an attack on an enemy. Success requires both to attack simultaneously when the enemy is unprepared. Communication is via messengers who can get lost.
• Naive Protocol: General 1 sends a message if the enemy is unprepared. General 2, if receiving the message, sends a confirmation. This back-and-forth continues.
• Strategic Behavior: Morris and Shin demonstrate that if generals act strategically (maximizing their own utility), the naturally prescribed protocol (even with confirmations) is inconsistent with rational behavior.
  • Payoff Structure: Attacking when the enemy is prepared is a disaster (-M). Successful coordinated attack yields 1. Not attacking yields 0.
  • The Dilemma: If General 1 sends a message but doesn't receive confirmation, they might believe their message was lost. If the probability of the message being lost is high enough, General 1 might decide not to attack, fearing General 2 won't attack. This logic can cascade.
  • The Counterintuitive Result: Even with highly reliable communication (small epsilon), strategic generals will never attack if they follow the naive communication protocol. This is because the uncertainty, however small, about the other general's knowledge leads to a cascade of non-action.
• Solution: The paper suggests that to achieve coordination, one might need to prevent the second general from trying to confirm an incoming message. This means either removing the ability to respond or having a commitment not to respond. The key takeaway is that protocols must consider the incentives of the participants.

Conclusion: Trust in Economics vs. Computer Science

The article concludes by emphasizing the fundamental difference in the notion of "trust" between economics and computer science.

• Economic Trust: Focuses on incentives and self-interest. Mechanisms are designed to induce desired behavior even in the absence of inherent trust.
• Computer Science Trust: Often assumes adherence to protocols. While fault tolerance is considered, the underlying assumption is that nodes will follow the algorithm unless they are faulty or adversarial.

When implementing mechanisms on a blockchain, this distinction is crucial. While blockchains aim to remove reliance on trusted third parties for validation, the economic perspective highlights that incentives still matter for participants within the system. Breaking down components like distributed ledgers, smart contracts, and encryption allows for a more nuanced understanding of where trust is placed and how it can be managed. Ultimately, participants decide what to trust, and often, some element of trust remains within any complex system.