Back to Research
Market Impact July 29, 2026 • 25 min read

Market Impact Modeling: Estimating Slippage and Decay

A quantitative study on estimating permanent and temporary price impact using the square-root law, linear-nonlinear model transitions, and order flow decay kernels on institutional execution streams.

Panoramic technical diagram showing lines of slippage and volatility spikes connected to neural network nodes analyzing order flow decay

1. Introduction: Understanding Market Impact

When executing large trades in financial markets, market participants inevitably shift the price of the asset in an unfavorable direction: buying drives the price up, and selling drives it down. This shift is defined as market impact. The difference between the decision price and the actual average execution price is known as slippage.

In high-frequency trading (HFT) and institutional order execution, precise estimation of price impact is critical. Quantitative analysis allows us to separate this impact into temporary and permanent components, as well as model the decay of price pressure after trading ceases.

2. Anatomy of Price Impact: Permanent vs. Temporary

Total market impact is mathematically decomposed into two components. The table below represents their differences, models, and operational mechanics:

Impact Component Definition / Cause Mathematical Model Decay Characteristics
Temporary Impact Local liquidity demand. Caused by eating through limit order book levels. $I_{temp} = \eta \cdot \left(\frac{V}{V_{adv}}\right)^\alpha \cdot \sigma$ Decays rapidly (sub-seconds) as new limit orders refill the book.
Permanent Impact Information dissemination. Markets adjust to the order as a signal. $I_{perm} = Y \cdot \sigma \cdot \sqrt{\frac{Q}{V_{adv}}}$ Does not decay easily; represents the new permanent equilibrium price.

3. Laws of Market Impact: The Square-Root Law

Empirical studies show that permanent market impact follows the square-root law. Under this empirical rule, the price shift is proportional to the square root of the executed volume $Q$, normalized by the average daily volume (ADV) $V_{adv}$:

$\Delta P = Y \cdot \sigma \cdot \sqrt{\frac{Q}{V_{adv}}}$

Where $\sigma$ represents the asset's daily volatility, and $Y$ is a dimensionless constant of order 0.5–0.7. This law is remarkably stable across different asset classes (equities, futures, cryptocurrencies) and indicates the non-linear nature of demand and supply dynamics in market microstructure.

However, at high trading speeds, the classical square-root model requires modifications. HFT algorithms incorporate order flow decay kernels, modeling the limit order book's recovery as a power-law process with memory: $K(t) \propto t^{-\gamma}$.

4. Machine Learning in Slippage Estimation

For precise dynamic slippage calculation, quant funds train machine learning models on historical meta-order execution logs. The feature vectors typically include:

  • **Participation Rate (PR)**: Our volume relative to total traded volume in the market.
  • **Order Flow Imbalance (OFI)**: The difference in buying and selling pressure on the top LOB levels.
  • **Trading Speed**: The quantity of shares or contracts executed per second.
  • **LOB Liquidity Depth**: The cumulative volume of orders sitting at the top 5 levels of the book.

5. Python Example: Simulating Price Impact and Recovery

The following Python script simulates the generation of temporary market impact and its exponential recovery over time:

import numpy as np

def simulate_market_impact(volume, adv, volatility, decay_rate=0.2, steps=100):
    """
    Simulates temporary market impact and its subsequent decay.
    Used in algorithmic execution to optimize trading pace.
    """
    # 1. Calculate initial temporary impact (nonlinear model)
    eta = 0.6  
    initial_impact = eta * volatility * np.sqrt(volume / adv)
    
    # 2. Model the decay of price pressure over time
    time_grid = np.arange(steps)
    # Exponential decay representing limit order book replenishment
    impact_decay = initial_impact * np.exp(-decay_rate * time_grid)
    
    # 3. Add high-frequency microstructure noise
    noise = np.random.normal(0, volatility * 0.05, steps)
    simulated_price_shift = impact_decay + noise
    
    return simulated_price_shift

# Simulate execution of 5% of ADV with 2% volatility
sim_data = simulate_market_impact(volume=5000, adv=100000, volatility=0.02)
print(f"Initial Price Shift: {sim_data[0]*10000:.2f} bps")
print(f"Price Shift after 10 steps: {sim_data[10]*10000:.2f} bps")

6. Conclusion

Market impact remains the fundamental barrier to scaling quantitative trading strategies. Decomposing impact into temporary and permanent components, combined with machine learning models, allows funds to execute large blocks with minimal slippage, ensuring efficient capital allocation across fragmented global order books.