market-microstructure-traditional Checked

price_change = lambda * net_order_flow

**Lambda (λ)** measures permanent price impact per unit of signed volume.

Higher lambda = less liquid market. Lambda is estimated by regressing

price changes on signed volume:

import numpy as np
from numpy.linalg import lstsq

def estimate_kyle_lambda(
    price_changes: np.ndarray,
    signed_volumes: np.ndarray,
) -> float:
    """Estimate Kyle's lambda from trade data.

    Args:
        price_changes: Midprice changes between trades.
        signed_volumes: Trade volume * trade_sign (+1 buy, -1 sell).

    Returns:
        Estimated lambda (price impact per unit volume).
    """
    X = signed_volumes.reshape(-1, 1)
    beta, _, _, _ = lstsq(X, price_changes, rcond=None)
    return float(beta[0])

See references/price_formation.md for full model derivations and the PIN

model for measuring informed trading probability.

---

Price Impact Models

### Temporary vs Permanent Impact (Almgren-Chriss)

When executing a large order:

• **Temporary impact** — price displacement that reverts after your order.

Caused by consuming standing liquidity.

• **Permanent impact** — information content of your trade that moves the

equilibrium price. Does not revert.

total_impact = permanent_impact + temporary_impact
permanent = gamma * (shares / ADV)
temporary = eta * (shares / time_horizon) ^ alpha

Typical alpha values: 0.5-0.7 (square root impact is a robust empirical finding).

### Square Root Impact Law

Empirically, price impact scales as the square root of order size relative

to daily volume:

def square_root_impact(
    order_size: float,
    daily_volume: float,
    volatility: float,
    impact_coefficient: float = 0.1,
) -> float:
    """Estimate price impact using the square root model.

    Args:
        order_size: Number of units to trade.
        daily_volume: Average daily volume.
        volatility: Daily return volatility (decimal).
        impact_coefficient: Empirical constant (typically 0.05-0.20).

    Returns:
        Expected price impact as a fraction.
    """
    return impact_coefficient * volatility * (order_size / daily_volume) ** 0.5

---

Order Book Imbalance

The ratio of bid-side to ask-side depth near the top of the book predicts

short-term price direction:

def order_book_imbalance(
    bid_qty: float,
    ask_qty: float,
) -> float:
    """Compute order book imbalance.

    Returns:
        Imbalance in [-1, 1]. Positive = more bids (bullish).
    """
    total = bid_qty + ask_qty
    if total == 0:
        return 0.0
    return (bid_qty - ask_qty) / total

Imbalance at levels 1-5 is a strong short-term predictor (Cont et al., 2014).

Deeper levels add predictive power but decay quickly.

---

Trade Arrival Processes

### Poisson Process

Simplest model: trades arrive at a constant rate λ. Inter-arrival times are

exponentially distributed. Useful as a baseline but too simple for real

order flow.

### Hawkes Process

Self-exciting point process where each trade increases the probability of

subsequent trades. Captures clustering in order flow:

intensity(t) = mu + sum(alpha * exp(-beta * (t - t_i)))

• **mu**: baseline arrival rate
• **alpha**: excitation magnitude (how much each event boosts intensity)
• **beta**: decay rate (how fast excitation fades)
• **alpha/beta < 1**: stationarity condition (branching ratio)

The branching ratio α/β measures the fraction of trades that are

*reactions* rather than *innovations*. Typical values: 0.5-0.8 in

crypto markets (high reactivity).

---

Market Maker Economics

A market maker profits from the spread but faces three risks:

1. **Adverse selection** — losing to informed traders

2. **Inventory risk** — accumulated directional exposure

3. **Competition** — other MMs narrowing the spread

### Avellaneda-Stoikov Model

The optimal bid and ask quotes for a market maker with inventory q:

reservation_price = midprice - q * gamma * sigma^2 * T
optimal_spread = gamma * sigma^2 * T + (2/gamma) * ln(1 + gamma/k)

Where:

• q: current inventory (positive = long)
• gamma: risk aversion parameter
• sigma: volatility
• T: time remaining
• k: order arrival rate parameter

Key insight: the reservation price *skews away from inventory* — a long

market maker lowers their price to encourage sells.

---

Execution Quality Measurement

### VWAP Benchmark

Volume-Weighted Average Price is the standard benchmark for passive execution:

def vwap(prices: list[float], volumes: list[float]) -> float:
    """Compute VWAP from trade prices and volumes."""
    pv_sum = sum(p * v for p, v in zip(prices, volumes))
    v_sum = sum(volumes)
    return pv_sum / v_sum if v_sum > 0 else 0.0

# Execution quality vs VWAP
slippage_vs_vwap = (avg_fill_price - vwap_benchmark) / vwap_benchmark * 10_000

### Implementation Shortfall

Measures total cost of executing vs the decision price (Perold, 1988):

implementation_shortfall = (execution_price - decision_price) * quantity

Decomposes into:

• **Delay cost**: price drift between decision and first fill
• **Market impact**: price move caused by your order
• **Timing